牛客暑假多校第二场 F trade

题意: 白兔有n个仓库,每个仓库有啊ai个货物,在每个仓库白兔可以装上任意数量的货物,也可以卸下任意数量的货物,现在有k个圆形信号阻隔器,然后有m个顾客下个一个订单，每个顾客的收货量有一个上限, 在每个订单中,白兔都会走过si个仓库, 从s[0] 按(输入)顺序依次遍历所有仓库, 当白兔遍历完所有仓库之后白兔会就会把车上的货物送到顾客家里。如果某个仓库和顾客的连线在某个圆形信号阻隔器的覆盖范围之内，那么白兔就不会去这个仓库。 求最后白兔给所有顾客的总的货物最多是多少。

题解：由于白兔在每个仓库的时候可以拿/放任意货物， 也就相当于白兔走过的仓库就已经是连起来了， 所以每次到一个新的仓库之后， 他就可以与前一个仓库所链接的所有仓库相连接了（单向），因为可以将连接的仓库的所有货物都放在这个仓库， 然后这个仓库到下一个仓库的时候就可以将这些货物带到下一个仓库， 也就是说仓库（单向）相连了， 可以任意的从前面的仓库把货物拿过来。 然后就是网络流模型了， 将每个仓库都与源点相连， 边值为货物数量上限， 每个顾客与可以走的仓库连线，边值为inf，所有顾客再与汇点相连，边值为顾客的最大收货量。 再跑一遍 s -> t的最大网络流就是答案了。

代码：

 #include<bits/stdc++.h>
 using namespace std;
 #define Fopen freopen("_in.txt","r",stdin); freopen("_out.txt","w",stdout);
 #define LL long long
 #define ULL unsigned LL
 #define fi first
 #define se second
 #define pb push_back
 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1
 #define max3(a,b,c) max(a,max(b,c))
 #define min3(a,b,c) min(a,min(b,c))
 #define db double
 double eps = 1e-;
 typedef pair<int,int> pll;
 const int inf = 0x3f3f3f3f;
 const LL INF = 0x3f3f3f3f3f3f3f3f;
 const LL mod =  (int)1e9+;
 const int N = 2e3+;
 const int M = 3e6+;
 int n, m, k;
 bitset<N>bit[N];
 int x1[N], y11[N], x3[N], y3[N], r[N], a[N];
 int x2[N], y2[N];
 struct Point{
     double x, y;
     Point(double _x, double _y){x = _x, y = _y;}
     double len(){return sqrt(x * x + y * y);}
     Point operator-(const Point &_){
         return Point(x - _.x, y - _.y);
     }
     double operator*(const Point &_){
         return x * _.y - y * _.x;
     }
     double operator%(const Point &_){
         return x * _.x + y * _.y;
     }
 };

 bool ok(int x, int y, int id){
     for (int h = ; h <= k; h ++){
         Point A = Point(x1[id], y11[id]), B = Point(x, y), P = Point(x3[h], y3[h]);
         Point result(, );
         double t = ((P - A) % (B - A)) / ((B - A) % (B - A));
         if (t >=  && t <= ){
             result = Point(A.x + (B.x - A.x) * t, A.y + (B.y - A.y) * t);
         }
         else{
             if ((P - A) % (P - A) < (P - B) % (P - B))
                 result = A;
             else
                 result = B;
         }
         if ((P - result) % (P - result) < r[h] * r[h] + eps) return ;
     }
     return ;
 }

 int head[N], to[M], nx[M];
 LL w[M];
 int deep[N], cur[N];
 int tot;
 int sz;
 void add(int u, int v, LL val){
     w[tot]  = val; to[tot] = v;
     nx[tot] = head[u]; head[u] = tot++;
 }
 int bfs(int s, int t){
     queue<int> q;
     memset(deep, , sizeof(int)*sz);
     q.push(s);
     deep[s] = ;
     while(!q.empty()){
         int u = q.front();
         q.pop();
         for(int i = head[u]; ~i; i = nx[i]){
             if(w[i] >  && deep[to[i]] == ){
                 deep[to[i]] = deep[u] + ;
                 q.push(to[i]);
             }
         }
     }
     return deep[t] > ;
 }
 LL Dfs(int u, int t, LL flow){
     if(u == t) return flow;
     for(int &i = cur[u]; ~i; i = nx[i]){
         if(deep[u]+ == deep[to[i]] && w[i] > ){
             LL di = Dfs(to[i], t, min(w[i], flow));
             if(di > ){
                 w[i] -= di, w[i^] += di;
                 return di;
             }
         }
     }
     return ;
 }
 LL Dinic(int s, int t){
     LL ans = , tmp;
     while(bfs(s, t)){
         for(int i = ; i <= sz; i++) cur[i] = head[i];
         while(tmp = Dfs(s, t, INF)) ans += tmp;
     }
     return ans;
 }
 void init(int _sz){
     memset(head, -, sizeof(head));
     tot = ;
     sz = _sz;
 }

 int main(){
     scanf("%d%d%d", &n, &m, &k);
     int s = , t = n+m+;
     init(t+);
     for(int i = ; i <= n; i++){
         scanf("%d%d%d", &x1[i], &y11[i], &a[i]);
         add(s,i,a[i]);
         add(i,s,);
         bit[i][i] = ;
     }
     for(int i = ; i <= k; i++)
         scanf("%d%d%d", &x3[i], &y3[i], &r[i]);
     int x, y, lim, b, c;
     for(int i = ; i <= m; i++){
         scanf("%d%d%d%d", &x, &y, &b, &lim);
         int last = ;
         while(b--){
             scanf("%d", &c);
             if(ok(x,y,c)) {
                 if(last) bit[c] |= bit[last];
                 last = c;
             }
         }
         if(!last) continue;
         add(n+i, t, lim);
         add(t, n+i, );
         for(int j = ; j <= n; j++)
            if(bit[last][j]){
               add(j, n+i, INF);
               add(n+i, j, );
         }
     }
     printf("%lld\n",Dinic(s,t));
     return ;
 }