bzoj1927

题意：给定一个图，还有一些有向边，每条边有一个权值w。对于每一个点，可以从其他任意一个点转移到这个点，时间为t。求从图外的一个点（即第一次一定是通过转移方式），遍历图中每个点一次最少需要的时间。。

思路：

      对于图中的每个点，需要满足的要求是进入一次，出去一次（即遍历一边）

     所以我们很容易想到拆点，把每个点拆成两个点。建图如下：

         <S, i, 1, 0>对应每个点进入一次

        <i+n, T, 1, 0>对应每个点出去一次

        <i, j + n, 1, wij>，如果ij有边对应i走到j

        <S, i, 1, t[i]>对应可以从其他点转移到这个点

   这样跑一遍最小费用流就是答案。

code：

#include <bits/stdc++.h>
using namespace std;
#define M0(a) memset(a, 0, sizeof(a))
#define Inf 0x3fffffff
const int maxn = 2010;
const int maxm = 200010;
struct edge{
     int v, f, c, next;
     edge(){}
     edge(int _v, int _f, int _c, int _next):v(_v), f(_f), c(_c), next(_next){}
};
struct Costflow{
     int last[maxn], pre[maxn], dis[maxn], vis[maxn];
     int tot, S, T;
     edge e[maxm];
     void add(int u, int v, int f, int c){
          e[tot] = edge(v, f, c, last[u]); last[u] = tot++;
          e[tot] = edge(u, 0, -c, last[v]); last[v] = tot++; 
     }
     void init(int S, int T){
          this->S = S, this->T = T;
          M0(e);
          memset(last, -1, sizeof(last));
          tot = 0;     
     }
     int spfa(){
          for (int i = 0; i <= T; ++i)
              dis[i] = Inf;
          memset(vis, 0, sizeof(vis));
          memset(pre, -1, sizeof(pre));
          dis[S] = 0;
          queue<int> q;
          q.push(S) , vis[S] = 1;
          int p, u, v;
          while (!q.empty()){
                p = last[u = q.front()];
                for ( ; p > -1; p = e[p].next){
                       v = e[p].v;
                       if (dis[u] + e[p].c < dis[v] && e[p].f > 0){
                             dis[v] = dis[u] + e[p].c;
                             pre[v] = p;
                             if (!vis[v]) vis[v] = 1, q.push(v);
                       }   
                }
                vis[u] = 0;
                q.pop();    
          }
          return dis[T] < Inf;  
     }
     int costflow(){
          int cost = 0, flow = 0;
          while (spfa()){
               int f = Inf;
               for (int p = pre[T]; p != -1; p = pre[e[p^1].v])
                      f = min(f, e[p].f);
               flow += f;
               cost += f * dis[T];
               for (int p = pre[T]; p != -1; p = pre[e[p^1].v])
                      e[p].f -= f, e[p^1].f += f;     
          }
          return cost;
     }
     /***********/ 
} F;
int n, m;
int t[maxn];

void solve(){
//     printf("%d %d\n", n, m);
     for (int i = 1; i <= n; ++i)
         scanf("%d", t+i);
     int S = 0, T = 2 * n + 1;
     F.init(S, T);
     for (int i = 1; i <= n; ++i)
         F.add(S, i + n, 1, t[i]), F.add(i+n, T, 1, 0), F.add(S, i, 1, 0);
     int u, v, w;
     for (int i = 1; i <= m; ++i){
         scanf("%d%d%d", &u, &v, &w);
         if (u > v) swap(u, v);
         F.add(u, v+n, 1, w);
     }
     int ans = F.costflow();
     cout << ans << endl;
}

int main(){
    while (scanf("%d%d", &n, &m) != EOF){
        solve();
    }            
}