BZOJ1003

/* CODEVS天梯也做得差不多了，现在做一些有意义的题目。*/

Description

物流公司要把一批货物从码头A运到码头B。由于货物量比较大，需要n天才能运完。货物运输过程中一般要转停好几个码头。物流公司通常会设计一条固定的运输路线，以便对整个运输过程实施严格的管理和跟踪。由于各种因素的存在，有的时候某个码头会无法装卸货物。这时候就必须修改运输路线，让货物能够按时到达目的地。但是修改路线是一件十分麻烦的事情，会带来额外的成本。因此物流公司希望能够订一个n天的运输计划，使得总成本尽可能地小。

Input

第一行是四个整数n（1<=n<=100）、m（1<=m<=20）、K和e。n表示货物运输所需天数，m表示码头总数，K表示每次修改运输路线所需成本。接下来e行每行是一条航线描述，包括了三个整数，依次表示航线连接的两个码头编号以及航线长度（>0）。其中码头A编号为1，码头B编号为m。单位长度的运输费用为1。航线是双向的。再接下来一行是一个整数d，后面的d行每行是三个整数P（ 1 < P < m）、a、b（1 < = a < = b < = n）。表示编号为P的码头从第a天到第b天无法装卸货物（含头尾）。同一个码头有可能在多个时间段内不可用。但任何时间都存在至少一条从码头A到码头B的运输路线。

Output

包括了一个整数表示最小的总成本。总成本=n天运输路线长度之和+K*改变运输路线的次数。

Sample Input

5 5 10 8

1 2 1

1 3 3

1 4 2

2 3 2

2 4 4

3 4 1

3 5 2

4 5 2

4

2 2 3

3 1 1

3 3 3

4 4 5

Sample Output

32

HINT

前三天走1-4-5，后两天走1-3-5，这样总成本为(2+2)*3+(3+2)*2+10=32

MARK一下，独立完成的第一道有质量的题目。

记f(i)为完成前i天航程所用的最小成本，则一定有一个j满足j天到i天的航程不更改路线且j-1天的路线与j天到i天的路线不同。

于是我们可以枚举这个j,注意到f(j-1)是无后效性的，因为无论怎样根据j的定义都要更改路线，类似它也具有子结构性质。

于是我们可以Dp了。

f(i)=Min[Cover(1,i)* i，f(j-1)+Cover(j,i) *(i-j+1)]

这个转移方程中Cover表示的是第j天到第i天不更改路线前提下可找到的s-t最短路，维护是比较简单的。

找最短路是因为上文叙述的最优子结构性质。

当然，上面的转移要求第j天到第i天存在不需更改路线的方案。

感觉这个转移是具有单调性的，不过没有细想，毕竟数据小，这样就可以AC了。

还是很开心，毕竟自己做出来的第一道省选题。

代码上的小细节见下(略繁琐，不建议直接使用)

[code]#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;

const int maxlongint=0x7fffffff;
const int INF=maxlongint/3;

struct Edge{
    int from,to;
    int w;
    Edge(){
        from=to=0;
        w=0;
    }
    Edge(int from_,int to_,int w_){
        from=from_;
        to=to_;
        w=w_;
    }
};

struct Line{
    int l,r;
    Line(){
        l=r=0;
    }
    Line(int l_,int r_){
        l=l_;
        r=r_;
    }
};

int l[105],r[105];
bool can[1005];
bool used[1005];
int dis[1005];
int f[1005];
int n,m;
vector<int> G[1005];
vector<Edge> edges;
vector<Line> Num[1005];
int k;

bool Init(Line q,int a,int b)
{
    return min(q.r,b)-max(q.l,a)>=0;
}

void AddEdge(int from,int to,int w)
{
    edges.push_back(Edge(from,to,w));
    edges.push_back(Edge(to,from,w));
    int m=edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}

void Bellman_Ford()
{
    memset(used,false,sizeof(used));
    queue<int> Q;
    for(int i=1;i<=m;i++)
        dis[i]=INF;
    dis[1]=0;
    Q.push(1);
    while(!Q.empty()){
        int u=Q.front();
        Q.pop();
        used[u]=false;
        for(int i=0;i<G[u].size();i++){
            Edge e=edges[G[u][i]];
            if(!can[e.to])
                continue;
            if(dis[e.to]>dis[u]+e.w){
                dis[e.to]=dis[u]+e.w;
                if(!used[e.to]){
                    used[e.to]=true;
                    Q.push(e.to);
                }
            }
        }
    }
}

int Cover(int a,int b)
{
    memset(can,true,sizeof(can));
    for(int i=1;i<=m;i++)
        for(int j=0;j<Num[i].size();j++)
            if(Init(Num[i][j],a,b))
                can[i]=false;
    Bellman_Ford();
    return dis[m];
}

void Solve()
{
    f[1]=Cover(1,1);
    for(int i=2;i<=n;i++){
        f[i]=Cover(1,i);
        if(f[i]!=maxlongint/3)
            f[i]*=i;
        for(int j=2;j<=i;j++){
            int ans=Cover(j,i);
            if(ans==INF)
                continue;
            f[i]=min(f[i],f[j-1]+(i-j+1)*ans+k);
        }
    }
    printf("%d\n",f
);
}

void Readdata()
{
    freopen("loli.in","r",stdin);
    int e;
    scanf("%d%d%d%d",&n,&m,&k,&e);
    for(int i=1;i<=e;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        AddEdge(a,b,c);
    }
    int d;
    scanf("%d",&d);
    for(int i=1;i<=d;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        Num[a].push_back(Line(b,c));
    }
}

void Close()
{
    fclose(stdin);
    fclose(stdout);
}

int main()
{
    Readdata();
    Solve();
    Close();
    return 0;
}