『hihocoder 1252』Kejin Game

题目链接:https://hihocoder.com/problemset/problem/1252

题意:
大家玩过游戏都知道技能树,点技能要一个一个点,某些大技要依靠之前的前置技能才能点着这个技能,现在有个Kejin Game. 反正有钱的人玩游戏根本不需要管这些,用钱就可以打破这些规律,例如取消当前边的依赖,或者直接用钱将该技能点亮,又或者一步一步按技能树来点. 问最少点亮目标技能s的最少花费.

分析:
做了2天的以前北京区域赛题目,感觉北京区域赛对基础知识的掌控非常稳,就不会有那种特别偏离的题,又或者不熟悉的数论题,那样做有点没意义.
这道题的模型是最大流最小割,我是想了好多种方法,但是还是想不通,然后就直接看题解了… 这建图真的好奇妙.要建立超级原点,超级汇点.
说说建图策略.

1. 当u->v 有弧,那么就按原来给出的边建图, 然后将u=>u’ 也就是 u’->v。
2. 与s连接切当前点的权值, s->u。
3. 与自身强行为切点建边 u->u’。
4. 最后汇点与目标点 aim 建边 aim’->t 流量INF.
5. 跑最大流就是答案.

例第一个样例
5 5 5
1 2 5
1 3 5
2 4 8
4 5 10
3 5 15
3 5 7 9 11
100 100 100 200 200

感受一下这个建图…至于正确性我是感觉出来的…我也是借鉴别人的.反正我是个蒟蒻啊…对网络流即熟悉又陌生。
说说我的感觉吧

首先对于s连接的点,如果按照拓扑序来说,我在拓扑序的某个节点接上尾点.联想最小割,点亮这些技能才能点最后一个aim,这切边就必须切那么多条.对吧?那么第一个模型解决了…

第2个模型,就是他可以直接点这个技能,那么我们分开差拆点,u和u’ 使他有权利切自己边成为最小流,就可以直接点亮技能了.对吧。。

第3个模型在与,u’->v 那么怎么理解,因为我可以抛弃我切当前点,我把那个边分出来,我就可以拒绝这个一栏,点其他技能就是了…因为s和->u有连着,这个你不切也不行啊.所以必定会点到.完全是个流, 大牛的思想就是厉害… 我是不会了…

代码:

/* Author:GavinjouElephant
 * Title:
 * Number:
 * main meanning：
 *
 *
 *
 */


#include <iostream>
using namespace std;
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <sstream>
#include <cctype>
#include <vector>
#include <set>
#include <cstdlib>
#include <map>
#include <queue>
//#include<initializer_list>
//#include <windows.h>
//#include <fstream>
//#include <conio.h>
#define MaxN 0x7fffffff
#define MinN -0x7fffffff
#define lson 2*k
#define rson 2*k+1
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=2e3+10;
int Scan()//读入整数外挂.
{
    int res = 0, ch, flag = 0;

    if((ch = getchar()) == '-')             //判断正负
        flag = 1;

    else if(ch >= '0' && ch <= '9')           //得到完整的数
        res = ch - '0';
    while((ch = getchar()) >= '0' && ch <= '9' )
        res = res * 10 + ch - '0';
    return flag ? -res : res;
}
 void Out(int a)    //输出外挂
 {
     if(a>9)
         Out(a/10);
     putchar(a%10+'0');
 }
 struct edge
 {
     int to,cap,rev;
 };
 vector<edge> G[maxn];
 int level[maxn];
 int iter[maxn];

 void add_edge(int from,int to,int cap)
 {
     G[from].push_back((edge){to,cap,G[to].size()});
     G[to].push_back((edge){from,0,G[from].size()-1});
 }

 void bfs(int s)
 {
     memset(level,-1,sizeof(level));
     queue<int> que;
     level[s]=0;
     que.push(s);
     while(!que.empty())
     {
         int v=que.front();
         que.pop();
         for(int i=0;i<G[v].size();i++)
         {
             edge &e=G[v][i];
             if(e.cap>0 && level[e.to]<0)
             {
                 level[e.to]=level[v]+1;
                 que.push(e.to);
             }
         }
     }
 }
 int dfs(int v,int t,int f)
 {
     if(v==t) return f;
     for(int &i=iter[v];i<G[v].size();i++)
     {
         edge &e=G[v][i];
         if(e.cap>0 && level[v]<level[e.to])
         {
             int d=dfs(e.to,t,min(f,e.cap));
             if(d>0)
             {
                 e.cap-=d;
                 G[e.to][e.rev].cap +=d;
                 return d;
             }
         }
     }
     return 0;
 }
 int max_flow(int s,int t)
 {
     int flow=0;
     for(;;)
     {
         bfs(s);
         if(level[t]<0) return flow;
         memset(iter,0,sizeof(iter));
         int f;
         while((f=dfs(s,t,INF))>0)
         {
             flow+=f;
         }
     }
     return flow;
 }
 int T;
 int n,m,p;
 int s;
 int t;
 int u,v,cap;
int main()
{
#ifndef ONLINE_JUDGE
    freopen("coco.txt","r",stdin);
    freopen("lala.txt","w",stdout);
#endif
    scanf("%d",&T);
    s=0;
    while(T--)
    {

        for(int i=0;i<=t;i++)G[i].clear();
        scanf("%d%d%d",&n,&m,&p);
        t=2*n+1;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&u,&v,&cap);
            add_edge(n+u,v,cap);
        }

        for(int i=1;i<=n;i++)
        {
            scanf("%d",&cap);
            add_edge(s,i,cap);
        }

        for(int i=1;i<=n;i++)
        {
            scanf("%d",&cap);
            add_edge(i,i+n,cap);
        }
        add_edge(p+n,t,INF);
        cout<<max_flow(s,t)<<endl;

    }

    return 0;
}