危险系数 割点

标题：危险系数

    抗日战争时期，冀中平原的地道战曾发挥重要作用。

    地道的多个站点间有通道连接，形成了庞大的网络。但也有隐患，当敌人发现了某个站点后，其它站点间可能因此会失去联系。
 
    我们来定义一个危险系数DF(x,y)：
    对于两个站点x和y (x != y), 如果能找到一个站点z，当z被敌人破坏后，x和y不连通，那么我们称z为关于x,y的关键点。相应的，对于任意一对站点x和y，危险系数DF(x,y)就表示为这两点之间的关键点个数。

    本题的任务是：已知网络结构，求两站点之间的危险系数。


    输入数据第一行包含2个整数n(2 <= n <= 1000), m(0 <= m <= 2000),分别代表站点数，通道数；
    接下来m行，每行两个整数 u,v (1 <= u, v <= n; u != v)代表一条通道；
    最后1行，两个数u,v，代表询问两点之间的危险系数DF(u, v)。

    输出：一个整数，如果询问的两点不连通则输出-1.


例如：
用户输入：
7 6
1 3
2 3
3 4
3 5
4 5
5 6
1 6
则程序应该输出：

2

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
//ExitWindowsEx关机
//讲解思路：求割点
//寻找路径数road
//记录每个点在连通路径中出现的次数r[i]
//if(r[i]==road)i为割点
//存储--邻接表

vector<int> map[1002];
int n,m;
bool visited[1002];
long road=0;
long r[1002];
long sum=0;
bool DFS(int u,int v){//深搜且存储路径中的点
    bool flag=false;
    if(u==v){
        road++;
        return true;
    }
    for(int i=0;i<map[u].size();i++){
        int w=map[u].at(i);
       if(!visited[w]){
            //cout<<u<<" "<<w<<endl;
            {
                visited[w]=1;
                flag=DFS(w,v);
                visited[w]=0;
                if(flag){
                    r[u]++;
                    //cout<<u<<endl;
                }
            }
        }
    }
    return flag;
}

int main(){
    int u,v;
    cin>>n>>m;
    for(int i=0;i<m;i++){
        cin>>u>>v;
        map[u].push_back(v);
        map[v].push_back(u);
    }
    cin>>u>>v;
    if(!DFS(u,v)){
        cout<<-1<<endl;
        return 0;
    }
    else{
        for(int i=1;i<=n;i++)
        if(i!=u||i!=v)
        if(r[i]==road)sum++;
    }
    //cout<<endl<<road;
    cout<<sum<<endl;
    return 0;
}
/*
//考试现场代码
using namespace std;
bool map[1002][1002]={0};
//矩阵存储
//基本思想：判断是否连通
//对路径上的每个点 从图中去掉再判断是否连通再还原
//运行错误
int visited[1002]={0};
int n,m;
int s=0;
int sum=0;
bool isCon(int u,int v);
queue <int>Q;
bool DFS(int u,int v){//深搜且存储路径中的点
    bool flag=false;
    if(u==v){
        s++;
        return true;
    }
    for(int i=1;i<=n;i++){
        if(map[u][i]){
            //cout<<u<<" "<<i<<endl;
            if(!visited[i]){
                visited[i]=1;
                flag=DFS(i,v);
                visited[i]=0;
                if(flag){
                    Q.push(u);
                }
            }
        }
    }
    return flag;
}
void df(int u,int v){
    for(int i=1;i<=n;i++){
        if(i!=u&&i!=v&&visited[i]){
          queue <int>q;
            for(int j=1;j<=n;j++){
                if(map[i][j]){
                    q.push(j);
                    map[i][j]=0;
                    map[j][i]=0;
                    
                }
            }
            if(!isCon(u,v))sum++;
            while(!q.empty())
            {
                int j=q.front();
                q.pop();
                map[i][j]=1;
                    map[j][i]=1;
            }
        }
    }
}

bool isCon(int u,int v){//广搜判断是否连通
    queue <int>q;
    for(int i=1;i<=n;i++)
    if(map[u][i]){
        if(i==v)return true;
        else q.push(i);
    }
    while(!q.empty()){
        int w=q.front();
        q.pop();
    for(int i=1;i<=n;i++)
        if(map[w][i]){
            if(i==v)return true;
            else q.push(i);
        }
    }
    
    return false;
}
int main(){
    cin>>n>>m;
    int u,v;
    for(int i=0;i<m;i++){
        scanf("%d%d",&u,&v);
        map[u][v]=1;
        map[v][u]=1;
    }
    cin>>u,v;
    if(u==v||map[u][v]){
        cout<<0<<endl;
        return 0;
    }
    

    if(isCon(u,v)){
        DFS(u,v);
     while(!Q.empty()){
         visited[Q.front()]=true;
         Q.pop();
     }
        df(u,v);
        cout<<sum<<endl;
    }
    else cout<<-1<<endl;
    
     cout<<s<<endl;
    return 0;
}
/*
#include <cstdio>
#include <iostream>
#include <vector>
#include <cstring>
//梁孝庆版本
using namespace std;

int u, v;
int vis[1005];
vector<int> vec[1005]; //数组vec的每一个元素都是vector<int>类型的动态数组
//邻接矩阵的方式存储图
 
bool dfs(int start)//深度优先搜索-->判断是否连通
{
    vector<int>::iterator it;//迭代器it
    for(it = vec[start].begin(); it != vec[start].end(); it++)
    {
        //遍历与源点start相连的每一个未访问节点
        if(vis[*it])
            continue;
        vis[*it] = 1;
        
        if(*it == v)
            return true;
        
        if(dfs(*it))
            return true;
    
        vis[*it] = 0;
    }
    return false;
}

int main()
{
    int n, m;
    int count = 0;
    
    scanf("%d %d", &n, &m);
    
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d",&u,&v);
        vec[u].push_back(v);
        vec[v].push_back(u);
    }
    scanf("%d%d", &u, &v);
    vis[u] = 1;
    
    if(!dfs(u))
    {
        puts("-1");
        return 0;
    }
    
    for(int i = 1; i <= n; i++)//遍历n个点
    {
        if(i == u || i == v)
            continue;
        memset(vis, 0, sizeof(vis));//每次初始化vis
        vis[u] = 1;//将起点和第i个点去掉
        vis[i] = 1;
        if(dfs(u)) //仍然连通count++
            count++;
    }
    
    printf("%d\n", n-2-count);//去掉源点和终点，去掉非割点，输出答案
    
    return 0;
}*/