HDU 3416 Marriage Match IV

Marriage Match IV

Time Limit: 1000ms

Memory Limit: 32768KB

This problem will be judged on HDU. Original ID: 3416
64-bit integer IO format: %I64d      Java class name: Main

Do not sincere non-interference。
Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girls are in city B. Every time starvae can get to city B and make a data with a girl he likes. But there are two problems with it, one is starvae must get to B within least time, it‘s said that he must take a shortest path. Other is no road can be taken more than once. While the city starvae passed away can been taken more than once.

So, under a good RP, starvae may have many chances to get to city B. But he don‘t know how many chances at most he can make a data with the girl he likes . Could you help starvae?

Input

The first line is an integer T indicating the case number.(1<=T<=65)
For each case,there are two integer n and m in the first line ( 2<=n<=1000, 0<=m<=100000 ) ,n is the number of the city and m is the number of the roads.

Then follows m line ,each line have three integers a,b,c,(1<=a,b<=n,0<c<=1000)it means there is a road from a to b and it‘s distance is c, while there may have no road from b to a. There may have a road from a to a,but you can ignore it. If there are two roads from a to b, they are different.

At last is a line with two integer A and B(1<=A,B<=N,A!=B), means the number of city A and city B.
There may be some blank line between each case.

Output

Output a line with a integer, means the chances starvae can get at most.

Sample Input

3
7 8
1 2 1
1 3 1
2 4 1
3 4 1
4 5 1
4 6 1
5 7 1
6 7 1
1 7

6 7
1 2 1
2 3 1
1 3 3
3 4 1
3 5 1
4 6 1
5 6 1
1 6

2 2
1 2 1
1 2 2
1 2

Sample Output

2
1
1

Source

HDOJ Monthly Contest – 2010.06.05

解题:直接把所有的最短路拿出来跑最小割

  1 #include <bits/stdc++.h>
  2 using namespace std;
  3 const int INF = 0x3f3f3f3f;
  4 const int maxn = 1010;
  5 struct arc{
  6     int to,w,next;
  7     arc(int x = 0,int y = 0,int z = -1){
  8         to = x;
  9         w = y;
 10         next = z;
 11     }
 12 }e[1000005];
 13 int head[maxn],hd[maxn],d[maxn],gap[maxn],tot,n,m,S,T;
 14 bool in[maxn] = {};
 15 void add(int head[maxn],int u,int v,int wa,int wb){
 16     e[tot] = arc(v,wa,head[u]);
 17     head[u] = tot++;
 18     e[tot] = arc(u,wb,head[v]);
 19     head[v] = tot++;
 20 }
 21 void spfa(){
 22     queue<int>q;
 23     memset(d,0x3f,sizeof d);
 24     d[S] = 0;
 25     q.push(S);
 26     while(!q.empty()){
 27         int u = q.front();
 28         q.pop();
 29         in[u] = false;
 30         for(int i = hd[u]; ~i; i = e[i].next){
 31             if(d[e[i].to] > d[u] + e[i].w){
 32                 d[e[i].to] = d[u] + e[i].w;
 33                 if(!in[e[i].to]){
 34                     in[e[i].to] = true;
 35                     q.push(e[i].to);
 36                 }
 37             }
 38         }
 39     }
 40     for(int i = 1; i <= n; ++i){
 41         for(int j = hd[i]; ~j; j = e[j].next){
 42             if(d[e[j].to] == d[i] + e[j].w)
 43                 add(head,i,e[j].to,1,0);
 44         }
 45     }
 46 }
 47 int dfs(int u,int low){
 48     if(u == T) return low;
 49     int tmp = 0,minH = n - 1;
 50     for(int i = head[u]; ~i; i = e[i].next){
 51         if(e[i].w){
 52             if(d[e[i].to] + 1 == d[u]){
 53                 int a = dfs(e[i].to,min(low,e[i].w));
 54                 e[i].w -= a;
 55                 e[i^1].w += a;
 56                 tmp += a;
 57                 low -= a;
 58                 if(!low) break;
 59                 if(d[S] >= n) return tmp;
 60             }
 61             if(e[i].w) minH = min(minH,d[e[i].to]);
 62         }
 63     }
 64     if(!tmp){
 65         if(--gap[d[u]] == 0) d[S] = n;
 66         ++gap[d[u] = minH + 1];
 67     }
 68     return tmp;
 69 }
 70 void bfs(){
 71     queue<int>q;
 72     memset(d,-1,sizeof d);
 73     memset(gap,0,sizeof gap);
 74     q.push(T);
 75     d[T] = 0;
 76     while(!q.empty()){
 77         int u = q.front();
 78         q.pop();
 79         ++gap[d[u]];
 80         for(int i = head[u]; ~i; i = e[i].next){
 81             if(d[e[i].to] == -1){
 82                 d[e[i].to] = d[u] + 1;
 83                 q.push(e[i].to);
 84             }
 85         }
 86     }
 87 }
 88 int sap(int ret = 0){
 89     bfs();
 90     while(d[S] < n) ret += dfs(S,INF);
 91     return ret;
 92 }
 93 int main(){
 94     int kase,u,v,w;
 95     scanf("%d",&kase);
 96     while(kase--){
 97         scanf("%d%d",&n,&m);
 98         memset(head,-1,sizeof head);
 99         memset(hd,-1,sizeof hd);
100         for(int i = tot = 0; i < m; ++i){
101             scanf("%d%d%d",&u,&v,&w);
102             if(u == v) continue;
103             add(hd,u,v,w,INF);
104         }
105         scanf("%d%d",&S,&T);
106         spfa();
107         printf("%d\n",sap());
108     }
109     return 0;
110 }

时间: 2024-12-16 07:14:14

HDU 3416 Marriage Match IV的相关文章

HDU 3416 Marriage Match IV(最短路+最大流)

HDU 3416 Marriage Match IV 题目链接 题意:给一个有向图,给定起点终点,问最多多少条点可以重复,边不能重复的最短路 思路:边不能重复,以为着每个边的容量就是1了,最大流问题,那么问题只要能把最短路上的边找出来,跑一下最大流即可,判断一条边是否是最短路上的边,就从起点和终点各做一次dijstra,求出最短路距离后,如果一条边满足d1[u] + d2[v] + w(u, v) == Mindist,那么这条边就是了 代码: #include <cstdio> #inclu

HDU 3416 Marriage Match IV(spfa+最大流)

题目的大体意思是:给你一些有向边让你求出给出的点s,t之间最短路的条数. 两边spfa从s到t,和从t到s然后求出在最短路上的点建一条容量为1的边,然后求出s到t的最大的流量,就是最短路的数目. PS:代码写的姿势不够优美. Marriage Match IV Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2051    Accept

hdu 3416 Marriage Match IV (最短路+最大流)

hdu 3416 Marriage Match IV Description Do not sincere non-interference. Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girls are in city B. Every time starvae can get to city B a

HDU 3416 Marriage Match IV(最短路+网络流之最大流)

题目地址:HDU 3416 这道题WA了一天半...最终才发现是我一直习惯性的将isap的表示上界的变量直接表示成sink+1了...但是在这道题里汇点sink不一定是最后一个点...sad... 这题可以有两种方法做,一种是求两次最短路,d1表示所有点到源点的最短距离,再求一次用d2表示所有点到汇点的最短距离.然后根据公式d1[u]+d2[v]+w==d1[sink]判断是否属于最短路中的一条边. 还有一种是只求一次最短路,直接用d[v]==d[u]+w来判断是否是可以到达源点的最短路,如果可

(中等) HDU 3416 Marriage Match IV,SPFA+SAP。

Description Do not sincere non-interference. Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girls are in city B. Every time starvae can get to city B and make a data with a girl

HDU - 3416 Marriage Match IV (最大流)

题目大意:有个人要从A城市去B城市,每条路只允许走一次,问能走几次最短路 解题思路:这题的话,难点就是怎么知道是不是最短路了 首先,先求出到B最短路,这也顺便求出了所有点到B的最短距离 接着求出到A的最短路 这样就能得到两个数组了,假设d1[u]代表u节点到A城市的最短路d2[v]代表v节点到城市B的最短距离 如果满足d1[u] + dis[u][v] + d2[v] == d1[v]的话,那么u,v这条路就属于最短路中的一条边了,那样就可以构边了 得将城市拆成两个点,容量为1 #include

hdu 3416 Marriage Match IV 【 最短路 最大流 】

求边不可重复的最短路条数 先从起点到终点用一次dijkstra,再从终点到起点用一次dijkstra,来判断一条边是否在最短路上 如果在,就将这条边的两个端点连起来,容量为1 再跑一下dinic(),最大流就是不可重复的最短路条数 还是想不到怎么建图啊------ 每次做网络流的题目--- 诶---该怎么建图啊--- 想了一会儿----啊--不会啊--- 搜一下题解吧--- 啊,原来这样连边啊--- 啊,原来需要---floyd / 并查集 /dijkstra /------ 啊---快,粘一粘

hdu 3081 hdu 3277 hdu 3416 Marriage Match II III IV //最大流的灵活运用

3081 题意: n个女孩选择没有与自己吵过架的男孩有连边(自己的朋友也算,并查集处理),2分图,有些边,求有几种完美匹配(每次匹配每个点都不重复匹配) 我是建二分图后,每次增广一单位,(一次完美匹配),再修改起点还有终点的边流量,继续增广,直到达不到完美匹配为止.网上很多是用二分做的,我觉得没必要...(网上传播跟风真严重...很多人都不是真正懂最大流算法的...) 3277 : 再附加一条件,每个女孩可以最多与k个自己不喜欢的男孩.求有几种完美匹配(同上). 我觉得:求出上题答案,直接ans

hdu 3081 hdu 3277 hdu 3416 Marriage Match II III IV //灵活运用最大流量

3081 意甲冠军: n女生选择不吵架,他甚至男孩边(他的朋友也算.并为您收集过程).2二分图,一些副作用,有几个追求完美搭配(每场比赛没有重复的每一个点的比赛) 后.每次增广一单位,(一次完美匹配),再改动起点还有终点的边流量,继续增广.直到达不到完美匹配为止.网上非常多是用二分做的,我认为不是必需. .. (网上传播跟风真严重.. . 非常多人都不是真正懂最大流算法的... ) 3277 : 再附加一条件,每一个女孩能够最多与k个自己不喜欢的男孩. 求有几种完美匹配(同上). 我认为:求出上