HDU 6582 Path

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 244    Accepted Submission(s): 50

Problem Description

Years later, Jerry fell in love with a girl, and he often walks for a long time to pay visits to her. But, because he spends too much time with his girlfriend, Tom feels neglected and wants to prevent him from visiting her.
After doing some research on the neighbourhood, Tom found that the neighbourhood consists of exactly n houses, and some of them are connected with directed road. To visit his girlfriend, Jerry needs to start from his house indexed 1 and go along the shortest path to hers, indexed n. 
Now Tom wants to block some of the roads so that Jerry has to walk longer to reach his girl's home, and he found that the cost of blocking a road equals to its length. Now he wants to know the minimum total cost to make Jerry walk longer.
Note, if Jerry can't reach his girl's house in the very beginning, the answer is obviously zero. And you don't need to guarantee that there still exists a way from Jerry's house to his girl's after blocking some edges.

 

Input

The input begins with a line containing one integer T(1≤T≤10), the number of test cases.
Each test case starts with a line containing two numbers n,m(1≤n,m≤10000), the number of houses and the number of one-way roads in the neighbourhood.
m lines follow, each of which consists of three integers x,y,c(1≤x,y≤n,1≤c≤109), denoting that there exists a one-way road from the house indexed x to y of length c.

 

Output

Print T lines, each line containing a integer, the answer.

Sample Input

1

3 4

1 2 1

2 3 1

1 3 2

1 3 3

 

Sample Output

3

 

Source

2019 Multi-University Training Contest 1

 

Recommend

We have carefully selected several similar problems for you:  6590 6589 6588 6587 6586 

吐槽

　　这么过分，一定要发朋友圈博客。杭电多校第一场(见上面那个source)，AC 1 题收场，就是这题。下两场可以休息了。本来第四题二分（https://www.cnblogs.com/wawcac-blog/p/11229277.html）也不难，但自己就是想不到。感觉自己现在还只会做板题。别人觉得难度更低的题，我就是想不出来。CF还是要接着打啊……

题意

　　原题在这https://www.cnblogs.com/wawcac-blog/p/7012556.html，上学路线的第二问，思路也在那了。只是数据范围增大了20倍，于是把Floyd改成dijkstra，几个int改成long long。理论上dinic是要T的，但它就是AC了……

源代码

 #include <queue>
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>

 int T;
 int n, m;

 struct Edge
 {
     int nxt, to;
     long long w;
 } e[], f[];
 int cnt = , head[], fcnt = , fhead[]; //正向图与反向图
 void add(int u, int v, long long w)
 {
     e[cnt] = {head[u], v, w};
     head[u] = cnt++;
     f[fcnt] = {fhead[v], u, w};
     fhead[v] = fcnt++;
 }

 long long dis[], fdis[];
 bool vis[];
 struct DijkHeap
 {
     int u;
     long long d;
     bool operator<(const DijkHeap &a) const
     {
         return d > a.d;
     }
 } dijktemp;
 void dijkstra()
 {
     std::priority_queue<DijkHeap> q;
     memset(dis, 0x7f, sizeof(long long) * (n + ));
     memset(vis, , sizeof(bool) * (n + ));
     dis[] = ;
     q.push({, });
     while (!q.empty())
     {
         dijktemp = q.top();
         q.pop();
         int u = dijktemp.u;
         long long d = dijktemp.d;
         vis[u] = ;
         for (int i = head[u]; i; i = e[i].nxt)
         {
             int v = e[i].to;
             if (vis[v])
                 continue;
             if (dis[v] > e[i].w + d)
             {
                 dis[v] = e[i].w + d;
                 q.push({v, dis[v]});
             }
         }
     }

     memset(fdis, 0x7f, sizeof(long long) * (n + ));
     memset(vis, , sizeof(bool) * (n + ));
     fdis[n] = ;
     q.push({n, });
     while (!q.empty())
     {
         dijktemp = q.top();
         q.pop();
         int u = dijktemp.u;
         long long d = dijktemp.d;
         vis[u] = ;
         for (int i = fhead[u]; i; i = f[i].nxt)
         {
             int v = f[i].to;
             if (vis[v])
                 continue;
             if (fdis[v] > f[i].w + d)
             {
                 fdis[v] = f[i].w + d;
                 q.push({v, fdis[v]});
             }
         }
     }
 }

 struct WEdge//最短路图
 {
     int nxt, to;
     long long flow;
 } we[];
 int whead[] = {}, wcnt = ;
 void wadd(int u, int v, long long f)
 {
     we[wcnt] = {whead[u], v, f};
     whead[u] = wcnt++;
     we[wcnt] = {whead[v], u, };
     whead[v] = wcnt++;
 }

 int dep[] = {};
 bool bfs()
 {
     memset(dep, , sizeof(int) * (n + ));
     std::queue<int> q;
     dep[] = ;
     q.push();
     while (!q.empty())
     {
         int u = q.front();
         q.pop();
         for (int i = whead[u]; i; i = we[i].nxt)
         {
             long long v = we[i].to;
             if (!dep[v] && we[i].flow)
             {
                 dep[v] = dep[u] + ;
                 q.push(v);
             }
         }
     }
     return dep[n] != ;
 }

 long long dfs(int u, long long fflow)
 {
     if (u == n || fflow == 0LL)
         return fflow;
     long long sum = ;
     for (int i = whead[u]; i; i = we[i].nxt)
     {
         int v = we[i].to;
         if (dep[v] == dep[u] +  && we[i].flow)
         {
             long long delta = dfs(v, std::min(fflow - sum, we[i].flow));
             sum += delta;
             we[i].flow -= delta;
             we[i ^ ].flow += delta;
             if (fflow <= sum)
                 break;
         }
     }
     if (!sum)
         dep[u] = -;
     return sum;
 }

 long long dinic()
 {
     long long ans = ;
     while (bfs())
     {
         while (long long temp = dfs(, 0x7f7f7f7f7f7f7f7f))
             ans += temp;
     }
     return ans;
 }

 void init()
 {
     cnt = fcnt = ;
     wcnt = ;
     memset(head, , sizeof(int) * (n + ));
     memset(fhead, , sizeof(int) * (n + ));
     memset(whead, , sizeof(int) * (n + ));
 }

 int main()
 {
     //freopen("test.in","r",stdin);
     scanf("%d", &T);
     while (T--)
     {
         init();
         scanf("%d%d", &n, &m);
         for (int i = , u, v, w; i <= m; i++)
         {
             scanf("%d%d%d", &u, &v, &w);
             add(u, v, (long long)w);
         }
         dijkstra();
         for (int u = ; u <= n; u++)
         {
             for (int i = head[u]; i; i = e[i].nxt)
             {
                 int v = e[i].to;
                 if (dis[u] + e[i].w + fdis[v] == dis[n])
                 {
                     wadd(u, v, e[i].w);
                     //printf("***%d   %d   %lld\n", u, v, e[i].w);
                 }
             }
         }
         printf("%lld\n", dinic());
     }
     return ;
 }