P3324 [SDOI2015]星际战争

传送门：https://www.luogu.org/problemnew/show/P3324

首先瞅一眼数据范围，发现m, n都很小，所以就可以初步断定这是一道网络流的题。

因为题中说每一个武器只能攻击特定的机器人，所以可以想象成这把武器有一条指向该机器人的边，那流量是多少呢？这是不确定的，因为武器攻击机器人的策略是不知道的。不过有一点可以确定，就是在时间t内，这把武器造成的伤害一定是b[i] * t，如果把武器i和源点连一条边，那么这条边的容量就是b[i] * t。

在考虑每一个机器人的装甲值，如果给个机器人i和汇点建立一条边，那么容量就是a[i]。这样我们就成功建立了一个图。

然后对 t 进行二分，如果在当时间为 t 时，到汇点的流量是sum(a[i])，那么就说明所有机器人都被打败了，就在左区间二分，否则说明 t 取小了，就在右区间二分。

因为题中说输出结果与标准答案的绝对误差不超过10-3即视为正确，所以我们把防御值扩大10000倍，这样在long long 范围内就可以解决了。

 #include<cstdio>
 #include<iostream>
 #include<cmath>
 #include<algorithm>
 #include<cstring>
 #include<cstdlib>
 #include<cctype>
 #include<stack>
 #include<queue>
 #include<vector>
 using namespace std;
 #define enter printf("\n")
 #define space printf(" ")
 #define Mem(a) memset(a, 0, sizeof(a));
 typedef long long ll;
 typedef double db;
 const int INF = 0x3f3f3f3f;
 const db eps = 1e-;
 const int maxn = 2e5 + ;
 inline ll read()
 {
     ll ans = ;
     char ch = getchar(), last = ' ';
     while(!isdigit(ch)) {last = ch; ch = getchar();}
     while(isdigit(ch))
     {
         ans = ans *  + ch - ''; ch = getchar();
     }
     if(last == '-') ans = -ans;
     return ans;
 }
 inline void write(ll x)
 {
     if(x < ) putchar('-'), x = -x;
     if(x >= ) write(x / );
     putchar(x %  + '');
 }
 //mrclr//
 
 int n, m, t;
 ll a[], b[];
 bool s[][];
 struct Edge
 {
     int from, to;
     ll cap, flow;
 };
 vector<Edge> edges;
 vector<int> G[maxn];
 
 void init()
 {
     edges.clear();
     for(int i = ; i < maxn; ++i) G[i].clear();
 
 }
 void addEdge(int from, int to, ll w)            //以下就是网络流的板子了
 {
     edges.push_back((Edge){from, to, w, });
     edges.push_back((Edge){to, from, , });
     int sz = edges.size();
     G[from].push_back(sz - );
     G[to].push_back(sz - );
 }
 
 int dis[maxn];
 bool vis[maxn];
 bool bfs()
 {
     Mem(vis);
     queue<int> q;
     q.push(); vis[] = ;
     dis[] = ;
     while(!q.empty())
     {
         int now = q.front(); q.pop();
         for(int i = ; i < (int)G[now].size(); ++i)
         {
             Edge& e = edges[G[now][i]];
             if(!vis[e.to] && e.cap > e.flow)
             {
                 vis[e.to] = ;
                 dis[e.to] = dis[now] + ;
                 q.push(e.to);
             }
         }
     }
     return vis[t];
 }
 int cur[maxn];
 ll dfs(int now, ll a)
 {
     if(now == t || !a) return a;
     ll flow = , f;
     for(int& i = cur[now]; i < (int)G[now].size(); ++i)
     {
         Edge& e = edges[G[now][i]];
         if(dis[e.to] == dis[now] +  && (f = dfs(e.to, min(a, e.cap - e.flow))) > )
         {
             e.flow += f;
             edges[G[now][i] ^ ].flow -= f;
             flow += f; a -= f;
             if(!a) break;
         }
     }
     return flow;
 }
 
 ll maxflow()
 {
     ll flow = ;
     while(bfs())
     {
         Mem(cur);
         flow += dfs(, (ll)INF * INF);
     }
     return flow;
 }
 
 ll sum = ;
 
 bool judge(ll tp)
 {
     init();
     for(int i = ; i <= m; ++i) addEdge(, i, b[i] * tp);        //把武器和源点建立一条容量为b[i] * time 的边
     for(int i = ; i <= n; ++i) addEdge(i + m, t, a[i]);        //把机器人和汇点建立一条容量为a[i]的边
     for(int i = ; i <= m; ++i)
         for(int j = ; j <= n; ++j)
             if(s[i][j]) addEdge(i, j + m, INF);
     //如果武器i能攻击机器人j，就建边，容量无穷，因为武器i有b[i] * time的限制
 //    printf("%lld %lld\n", maxflow(), sum);
     //调试的时候请不要这么写，因为maxflow()跑完后已经成残量网络了，在上面跑自然不对
     return maxflow() == sum;
 }
 
 int main()
 {
     n = read(); m = read();            //防御值扩大1e4倍
     t = n + m + ;
     for(int i = ; i <= n; ++i) {a[i] = read(); a[i] *= ; sum += a[i];}
     for(int i = ; i <= m; ++i) b[i] = read();
     for(int i = ; i <= m; ++i)
         for(int j = ; j <= n; ++j)
             {int x = read(); s[i][j] = x;}
     ll L = , R = (ll)INF * (ll)INF;
     while(L < R)
     {
         int mid = (L + R) >> ;
         if(judge(mid)) R = mid;
         else L = mid + ;
     }
     printf("%.5lf\n", (double)L / );
     return ;
 }