OpenJudge 1031 Lausanne Capitale Olympique

Lausanne Capitale Olympique

Time Limit: 1000ms

Memory Limit: 65536KB

This problem will be judged on OpenJudge. Original ID: 1031
64-bit integer IO format: %lld      Java class name: Main

 

Lausanne is a city in the French-speaking part of Switzerland. The headquarters of the International Olympic Committee (IOC) are located here; therefore Lausanne is also called the Olympic Capital.

As the London 2012 Olympics is coming, the IOC members frequently come to Lausanne to have meetings. Fortunately, IOC has a partner Lausanne Airways, which provides the IOC members with free flights.

Nevertheless, the IOC members live all over the world, and flights of Lausanne Airways are limited, so sometimes several transfers are unavoidable. For example, if a member lives in Shanghai, maybe he needs first fly to Beijing, then Paris, then Geneva, and finally arrived in Lausanne, which contains 3 transfers.

For convenience’s sake, the IOC members will always choose the trip with the minimum transfer times. However, due to the bad weather, some flights may be canceled, thus some members’ trip must be rescheduled. Lausanne Airways predicts that if there is only one flight canceled, then the minimum transfer times increases at most one for any IOC member.

Please check whether the above prediction is accomplished. Please note that all the flights mentioned above are two-way.

 

Input

The first line contains two integers n, m (1 ≤ n ≤ 10000, 1 ≤ m ≤ 100000), indicates that the IOC members live in n different cities, numbered from 1 to n, which 1 stands for Lausanne and 2~n for other cities.
Then there follows m lines, each of them contains two integers x, y (1 ≤ x, y ≤ n, x ≠ y), indicates there is a flight between city x and city y. It is guaranteed that there is at most one flight between any two cities, and these n cities are connected.

 

Output

If the prediction is accomplished, output 1; otherwise output 0.
If after a certain flight being canceled, these n cities are no longer connected, also output 0.

 

Sample Input

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

Sample Output

0

解题：。。哈哈，假设去掉边u->v，那么1到v就要改道，长度不能大于1啊，如果能够到v的变长不超过1，那么经过v的其他道路最长也不会增加超过1.

所以，看v的邻边，如果可以从v的邻点到此，那么就好了，要满足增长不大于1，那么1到v的邻点的长度应该为d[v]或者为d[v]-1。。。好了，直接枚举点的邻点就好了。。。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <climits>
#include <vector>
#include <queue>
#include <cstdlib>
#include <string>
#include <set>
#include <stack>
#define LL long long
#define pii pair<int,int>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 10010;
struct arc{
    int to,next;
    arc(int x = 0,int y = -1){
        to = x;
        next = y;
    }
};
arc e[maxn*20];
int head[maxn],d[maxn],q[maxn*10];
int tot,n,m;
bool done[maxn];
void add(int u,int v){
    e[tot] = arc(v,head[u]);
    head[u] = tot++;
    e[tot] = arc(u,head[v]);
    head[v] = tot++;
}
void bfs(){
    int hd = 0,tl = 0;
    for(int i = 1; i <= n; ++i) d[i] = INF;
    d[1] = 0;
    q[tl++] = 1;
    while(hd < tl){
        int u = q[hd++];
        for(int i = head[u]; ~i; i = e[i].next){
            if(d[e[i].to] > d[u] + 1){
                d[e[i].to] = d[u] + 1;
                q[tl++] = e[i].to;
            }
        }
    }
}
int main() {
    int u,v;
    while(~scanf("%d %d",&n,&m)){
        memset(head,-1,sizeof(head));
        for(int i = tot = 0; i < m; ++i){
            scanf("%d %d",&u,&v);
            add(u,v);
        }
        bfs();
        bool ans = true;
        for(int i = 2; ans && i <= n; ++i){
            int cnt = 0;
            for(int k = head[i]; ~k; k = e[k].next)
                if(d[e[k].to] <= d[i] && ++cnt > 2) break;
            if(cnt < 2) ans = false;
        }
        printf("%d
",ans);
    }
    return 0;
}