BZOJ--1266: [AHOI2006]上学路线route--最短路+网络流

1266: [AHOI2006]上学路线route

Time Limit: 3 Sec  Memory Limit: 162 MB
Submit: 2766  Solved: 1037
[Submit][Status][Discuss]

Description

可可和卡卡家住合肥市的东郊，每天上学他们都要转车多次才能到达市区西端的学校。直到有一天他们两人参加了学校的信息学奥林匹克竞赛小组才发现每天上学的乘车路线不一定是最优的。 可可：“很可能我们在上学的路途上浪费了大量的时间，让我们写一个程序来计算上学需要的最少时间吧！” 合肥市一共设有N个公交车站，不妨将它们编号为1…N的自然数，并认为可可和卡卡家住在1号汽车站附近，而他们学校在N号汽车站。市内有M条直达汽车路线，执行第i条路线的公交车往返于站点pi和qi之间，从起点到终点需要花费的时间为ti。(1<=i<=M, 1<=pi, qi<=N) 两个人坐在电脑前，根据上面的信息很快就编程算出了最优的乘车方案。然而可可忽然有了一个鬼点子，他想趁卡卡不备，在卡卡的输入数据中删去一些路线，从而让卡卡的程序得出的答案大于实际的最短时间。而对于每一条路线i事实上都有一个代价ci：删去路线的ci越大卡卡就越容易发现这个玩笑，可可想知道什么样的删除方案可以达到他的目的而让被删除的公交车路线ci之和最小。 [任务] 编写一个程序：  从输入文件中读取合肥市公交路线的信息；  计算出实际上可可和卡卡上学需要花费的最少时间；  帮助可可设计一个方案，删除输入信息中的一些公交路线，使得删除后从家到学校需要的最少时间变大，而被删除路线的ci和最小；向输出文件输出答案。

Input

输入文件中第一行有两个正整数N和M，分别表示合肥市公交车站和公交汽车路线的个数。以下M行，每行（第i行，总第(i+1)行）用四个正整数描述第i条路线：pi, qi, ti, ci；具体含义见上文描述。

Output

输出文件最多有两行。 第一行中仅有一个整数，表示从可可和卡卡家到学校需要的最短时间。 第二行输出一个整数C,表示Ci之和

Sample Input

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

Sample Output

2
5
 

HINT

2<=N<=500, 1<=M<=124 750, 1<=ti, ci<=10 000
合肥市的公交网络十分发达，你可以认为任意两个车站间都可以通过直达或转车互相到达，当然如果在你提供的删除方案中，家和学校无法互相到达，那么则认为上学需要的最短为正无穷大：这显然是一个合法的方案。

Source

一模一样的题---https://blog.csdn.net/lanshan1111/article/details/100935227

/**************************************************************
    Problem: 1266
    User: pre111
    Language: C++
    Result: Accepted
    Time:304 ms
    Memory:9100 kb
****************************************************************/
 
#include <algorithm>　　　 //STL通用算法
#include <bitset>　　　　　//STL位集容器
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>　　　　　 //STL双端队列容器
#include <exception>　　　 //异常处理类
#include <fstream>
#include <functional>　　　//STL定义运算函数（代替运算符）
#include <limits>
#include <list>　　　　　　//STL线性列表容器
#include <map>　　　　　　 //STL 映射容器
#include <iomanip>
#include <ios>　　　　　　//基本输入／输出支持
#include<iosfwd>　　　　　//输入／输出系统使用的前置声明
#include <iostream>
#include <istream>　　　　 //基本输入流
#include <ostream>　　　　 //基本输出流
#include <queue>　　　　　 //STL队列容器
#include <set>　　　　　　 //STL 集合容器
#include <sstream>　　　　//基于字符串的流
#include <stack>　　　　　 //STL堆栈容器　　　　
#include <string>　　　　　//字符串类
#include <vector>　　　　　//STL动态数组容器
#define ll long long
using namespace std;
#define rep(i,a,b) for(register int i=(a);i<=(b);i++)
#define dep(i,a,b) for(register int i=(a);i>=(b);i--)
using namespace std;
const int maxn = 500 + 5;
const int maxm=2*124750+5;
typedef pair<int, int> P;
const ll INF = 0x3f3f3f3f3f3f3f3f;
int n, m, cas;
 
int d[maxm];
struct GDJ
{
    int head[maxn], cnt;
    int to[maxm], nxt[maxm];
    int val[maxm];
    int va[maxm];
    void init()
    {
        memset(head, -1, (n + 5) * sizeof(int));
        memset(va,0,(n + 5) * sizeof(int));
        cnt = -1;
    }
 
    void ade(int a, int b, int c,int d)
    {
        to[++cnt] = b;
        nxt[cnt] = head[a];
        val[cnt] = c;
        va[cnt]=d;
        head[a] = cnt;
    }
 
    bool vis[maxn];
    void dj(int s)
    {
        priority_queue<P, vector<P>, greater<P> > que;
        memset(d, 0x3f, (n + 5) * sizeof(int));
        memset(vis, 0, (n + 5) * sizeof(bool));
        d[s] = 0;
        que.push(P(0, s));
        while(!que.empty())
        {
            P p = que.top();
            que.pop();
            int u = p.second;
            if(vis[u])
                continue;
            vis[u] = 1;
            for(int i = head[u]; ~i; i = nxt[i])
            {
                int v = to[i];
                if(d[v] > d[u] + val[i])
                {
                    d[v] = d[u] + val[i];
                    que.push(P(d[v], v));
                }
            }
        }
    }
} DJ;
 
struct GDC
{
    int depth[maxn], cur[maxn], head[maxn], cnt;
    int to[maxm], nxt[maxm];
    int val[maxm];
 
    void init()
    {
        memset(head, -1, (n + 5) * sizeof(int));
        cnt = -1;
    }
 
    void ade(int a, int b, int c)
    {
        to[++cnt] = b;
        nxt[cnt] = head[a];
        val[cnt] = c;
        head[a] = cnt;
    }
 
    bool bfs()
    {
        queue<int> que;
        que.push(1);
        memset(depth, 0, (n + 5) * sizeof(int));
        depth[1] = 1;
        while(!que.empty())
        {
            int u = que.front();
            que.pop();
            for(int i = head[u]; ~i; i = nxt[i])
            {
                if(val[i] > 0 && depth[to[i]] == 0)
                {
                    depth[to[i]] = depth[u] + 1;
                    que.push(to[i]);
                }
            }
        }
        if(depth[n])
            return 1;
        else
            return 0;
    }
 
    int dfs(int u, int dist)
    {
        if(u == n)
            return dist;
        for(int &i = cur[u]; ~i; i = nxt[i])
        {
            if(depth[to[i]] == depth[u] + 1 && val[i] > 0)
            {
                int tmp = dfs(to[i], min(dist, val[i]));
                //cout<<tmp<<"---"<<endl;
                if(tmp > 0)
                {
                    val[i] -= tmp;
                    val[i ^ 1] += tmp;
                    return tmp;
                }
            }
        }
        return 0;
    }
 
    int dinic()
    {
        int res =0, dd;
        while(bfs())
        {
            for(int i = 0; i <= n; i ++)
                cur[i] = head[i];
            while(dd = dfs(1,INF))
            {
                res += dd;
            }
        }
        return res;
    }
} DC;
 
int main()
{
    scanf("%d %d",&n,&m);
    DJ.init();
    for(int i = 1; i <= m; i++)
    {
        int a, b;
        int c,d;
        scanf("%d %d %d %d",&a,&b,&c,&d);
        DJ.ade(a, b, c, d);
        DJ.ade(b, a, c, d);
    }
    DJ.dj(1);
    DC.init();
    for(int u = 1; u <= n; u ++)
    {
        for(int i = DJ.head[u]; ~i; i = DJ.nxt[i])
        {
            int v = DJ.to[i];
            int cst = DJ.val[i];
            if(d[v] == cst+d[u])
            {
                DC.ade(u, DJ.to[i], DJ.va[i]), DC.ade(DJ.to[i],u,0);
            }
        }
    }
    printf("%d %d\n",d[n],DC.dinic());
 
    return 0;
}