POJ 3343 Against Mammoths(二分匹配+二分答案)

题意：（这个题目好长~~~)有n个人类星球，m个外星球，每个星球上开始sh艘飞船，之后每年会生产p艘飞船，人类想要战胜所有的外星球，每个人类星球和每个外星球的距离已知（需要耗费k年），比如在a年初，人类星球H向外星球A宣战，那么人类会带上sh+p*a艘飞船进攻，经过k年后到达外星球，这时外星球飞船的数量为sh'+p'*(a+k)，如果这时人类飞船的数量>=外星球飞船的数量，那么就会战胜这个外星球，每个人类星球只能攻击一个外星球，一个外星球只能被一个人类星球攻击，问最少需要多少年人类才能全部战胜所有的外星球。

思路：由于人类星球和外星球是一一对应的关系，所以自然想到了二分匹配，但是时间是未知的，所以可以通过二分答案的途径来确定时间，对于每个时间k检测人类是否能打败所有的外星球.....输出最小值就可以了，由于答案是从1<<31-1开始二分的，所以计算过程中可能会超出int范围，故要注意__int64类型的转换。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <memory.h>
#include <cmath>
#include <bitset>
#include <queue>
#include <vector>
using namespace std;

const int BORDER = (1<<26)-1;
const int MAXSIZE = 37;
const int MAXN = 300;
const int INF = 0x6ffffff;
#define CLR(x,y) memset(x,y,sizeof(x))
#define ADD(x) x=((x+1)&BORDER)
#define IN(x) scanf("%d",&x)
#define OUT(x) printf("%d\n",x)
#define MIN(m,v) (m)<(v)?(m):(v)
#define MAX(m,v) (m)>(v)?(m):(v)
#define ABS(x) ((x)>0?(x):-(x))

typedef struct{
    int v,next;
    int val;
}Edge;
typedef struct{
    int sh;
    int p;
}Node;
int n,m,ans,index;
int dist[MAXN][MAXN],net[MAXN],pre[MAXN];
bool visit[MAXN];
Edge edge[MAXN*MAXN];
Node hum[MAXN],mam[MAXN];

void add_edge(const int& u,const int& v)
{
    edge[index].v = v;
    edge[index].next = net[u];
    net[u] = index;
    ++index;
}
bool _check(const Node& a,const Node& b,const int& dis,const int& limit)
{
    if(limit < dis)
        return false;
    if(a.sh >= b.sh+(__int64)dis*b.p)
        return true;
    if(a.sh+(__int64)(limit-dis)*a.p >= b.sh+(__int64)limit*b.p)
        return true;
    return false;
}
int init()
{
    index = 0;
    ans = -1;
    CLR(net,-1);
    CLR(pre,-1);
    return 0;
}
int input()
{
    int i,j,a,b,val;
    for(i = 0; i < n; ++i)
        scanf("%d%d",&hum[i].sh,&hum[i].p);
    for(i = 0; i < m; ++i)
        scanf("%d%d",&mam[i].sh,&mam[i].p);
    for(i = 0; i < n; ++i)
        for(j = 0; j < m; ++j)
        {
            scanf("%d",&dist[i][j]);
        }
    return 0;
}
bool dfs(const int& u)
{
    int i,v;
    for(i = net[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].v;
        if(!visit[v])
        {
            visit[v] = true;
            if(pre[v] == -1 || dfs(pre[v]))
            {
                pre[v] = u;
                return true;
            }
        }
    }
    return false;
}
int make_graph(const __int64& limit)
{
    int i,j,val,u,v,tmp;
    index = 0;
    CLR(net,-1);
    CLR(pre,-1);
    for(i = 0; i < n; ++i)
        for(j = 0; j < m; ++j)
        {
            if(_check(hum[i],mam[j],dist[i][j],limit))
                add_edge(i,j);
        }
    return 0;
}
int work()
{
    int i,j,tmp;
    __int64 b_low = 0;
    __int64 b_high = (1<<31)-1;
    __int64 b_mid;
    while(b_low <= b_high)
    {
        b_mid = (__int64)(b_low+b_high)>>1;
        make_graph(b_mid);
        tmp = 0;
        for(i = 0; i < n; ++i)
        {
            CLR(visit,0);
            if(dfs(i))
                ++tmp;
        }
        if(tmp == m)
        {
            ans = b_mid;
            b_high = b_mid - 1;
        }
        else
            b_low = b_mid + 1;
    }
    if(ans == -1)
        printf("IMPOSSIBLE\n");
    else
        OUT(ans);
    return 0;
}
int main()
{
    while(scanf("%d%d",&n,&m))
    {
        if(!n && !m)
            break;
        init();
        input();
        work();
    }
    return 0;
}