51Nod 1444 破坏道路(最短路+枚举)

在某一个国家，那儿有n个城市，他们通过m条双向道路相连。城市从1到n编号。如果城市a和b通过一条道路直接相连，那么他们之间的距离就是一个小时。这个国家的道路网络可以允许你从任意一个城市到达另外的城市。

现在你要破坏尽可能多的道路，但是要保证从城市s1到t1不超过l1小时，并且从城市s2到t2不超过l2小时。

输出最多可以破坏的道路数目，如果没有解，请输出-1




Input
单组测试数据。
第一行有两个整数n,m(1 ≤ n ≤ 3000, n-1 ≤ m ≤ min(3000,n*(n-1)/2) )。
接下来m行，每行有两个整数 ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi)，表示ai和bi之间有一条道路。
输入保证是一个连通图。
最后两行每行有三个整数s1, t1, l1和 s2, t2, l2, (1 ≤ si, ti ≤ n, 0 ≤ li ≤ n)。

Output
输出一个整数，表示最多可以破坏的道路数目，如果没有解，输出-1。

Input示例
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 2

Output示例

0

分析：首先使剩下的路径越少越好。 不一定是那么，两条路径要么右重叠的路径要么没有，枚举重叠的路径。

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<vector>
const int maxn = 3000;
const int inf = 1e9;
typedef long long ll;
using namespace std;
struct HeapNode
{
    int d,u;
    bool operator < (const HeapNode &rhs) const
    {
        return d > rhs.d;
    }
};
struct Edge
{
    int fr,to,dist;
};
int n,m;
vector<Edge>edges;
vector<int>G[maxn+5];
bool done[maxn+5];
int d[maxn+5][maxn+5];

void init()
{
    for(int i=0; i<=n; i++) G[i].clear();
    edges.clear();
}

void addedge(int fr,int to,int dist)
{
    edges.push_back((Edge)
    {
        fr,to,dist
    });
    int l = edges.size();
    G[fr].push_back(l-1);
}

void dijkstra(int s,int d[])
{
    queue<int>Q;
    Q.push(s);
    for(int i=1;i<=n;i++) d[i] = inf;
    d[s] = 0;
    while(!Q.empty())
    {
        int x = Q.front();
        Q.pop();
        for(int i=0,l=G[x].size();i<l;i++)
        {
            Edge e=edges[G[x][i]];
            if(d[e.to]>d[x]+1)
            {
                d[e.to] = d[x] + 1;
                Q.push(e.to);
            }
        }
    }
}

int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        init();
        for(int i=1; i<=m; i++)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            addedge(x,y,1), addedge(y,x,1);
        }
        for(int i=1;i<=n;i++) dijkstra(i,d[i]);
        int s1,t1,s2,t2,l1,l2;
        scanf("%d %d %d",&s1,&t1,&l1);
        scanf("%d %d %d",&s2,&t2,&l2);
        int ans = inf;
        if(d[s1][t1]<=l1&&d[s2][t2]<=l2) ans = d[s1][t1]+d[s2][t2];

        for(int i=1;i<=n;i++)
        {
            for(int j=i;j<=n;j++)
            {
                //不需要当心 路径有走重复（比如 d[i][j]路径包含s.) 因为后答案肯定是 是正确的且肯定是最小的ans。
                if(d[s1][i]+d[j][t1]+d[i][j]<=l1&&d[s2][i]+d[j][t2]+d[i][j]<=l2) ans = min(ans,d[s1][i]+d[j][t1]+d[i][j]+d[s2][i]+d[j][t2]);
                if(d[s1][j]+d[i][t1]+d[i][j]<=l1&&d[s2][j]+d[i][t2]+d[i][j]<=l2) ans = min(ans,d[s1][j]+d[i][t1]+d[i][j]+d[s2][j]+d[i][t2]);
                if(d[s1][i]+d[j][t1]+d[i][j]<=l1&&d[s2][j]+d[i][t2]+d[i][j]<=l2) ans = min(ans,d[s1][i]+d[j][t1]+d[i][j]+d[s2][j]+d[i][t2]);
                if(d[s1][j]+d[i][t1]+d[i][j]<=l1&&d[s2][i]+d[j][t2]+d[i][j]<=l2) ans = min(ans,d[s1][j]+d[i][t1]+d[i][j]+d[s2][i]+d[j][t2]);
            }
        }

        if(ans == inf || ans>m) ans = m+1;
        printf("%d\n",m-ans);
    }
    return 0;
}