[20151020]SCZ训练

题1：北京地图

问题描述:
北京地图可以看作是 R*C 的网格，奥运会期间对有的地方要进行交通管制，有的地方不允许进入，有的地方对离开时的行驶方向有限制：有的只允许走到上下两个相邻的格子，有的只允许走到左右两个相邻的格子，没有的任何限制的地方上下左右四个方向都允许。
现在给你地图的描述，格子的描述如下：
● “+”表示可以向任意方向（上、下、左、右）移动一格；
● “-”表示只能向左右方向移动一格；
● “|”表示只能向上下方向移动一格；
● “*”表示该位置不能到达。
你的任务是计算出从左上角到右下角的最少需要经过的格子数。
输入说明：
第一行一个整数t(1<=t=10)，表示有t组测试数据。
每一个测试数据，第一行一个整数r，第二行一个整数 c，表示地图是 r 行 c 列的，接下来 r 行，每行 c 个字符，每个字符是{+,*,-,|}中的一种。
你可以假设左上角不会是“*”。
输出说明：
输出有t行，每行一个整数表示对应测试数据所需的最少格子数，如果到达不了右下角输出-1。
数据说明：
50% 1<=r,c<=20
100% 1<=r,c<=1000

Solution :
$BFS.$
$BigForceMakesMiracles$

Code :

/*************************************************************************
    > File Name: S.cpp
    > Author: Archer
 ************************************************************************/

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;

const int N = 1111;
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef pair<pair<int, int>, int> PII;
#define REP(i, l, r) for (int i = l; i <= r; i++)
#define MP make_pair
#define MS(_) memset(_, 0, sizeof(_));
#define fst first
#define sec second
using namespace std;

char s[N][N];
int dist[N][N], n, m, l, r;
int Q[N*N][2];

inline void setIO(){
    freopen("S.in", "r", stdin);
    freopen("S.out", "w", stdout);
}
inline int read(){
    int x = 0, f = 1; char ch = getchar();
    while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar(); }
    return f ? x : -x;
}

inline void check(int x, int y, int d){
    if (s[x][y] == '*' || dist[x][y] < INF) return;
    if (x <= 0 || y <= 0 || x > n || y > m) return;
    Q[++r][0] = x; Q[r][1] = y; dist[x][y] = d;
}
void bfs(){
    memset(dist, 0x3f, sizeof dist);
    Q[1][0] = Q[1][1] = dist[1][1] = 1;
    l = 1, r = 1;
    while (l <= r){
        int nx = Q[l][0], ny = Q[l][1], nd = dist[nx][ny] + 1; l++;
        if (s[nx][ny] == '-' || s[nx][ny] == '+') {check(nx, ny - 1, nd); check(nx, ny + 1, nd);}
        if (s[nx][ny] == '|' || s[nx][ny] == '+') {check(nx - 1, ny, nd); check(nx + 1, ny, nd);}
    }
}
int main(){
    setIO();

    for (int T = read(); T--;){
        n = read(); m = read();
        REP(i, 1, n) scanf("%s", s[i] + 1);
        bfs();
        printf("%d\n", dist[n][m] < INF ? dist[n][m] : -1);
    }
    return 0;
}

题2：交通网

问题描述
S国有N个城市，城市之间由道路直接或间接相连。在建设交通的过程中，为了减少建设费用，逐渐形成了任意两个城市之间都有且仅有一条简单路径的布局。
城市与城市之间的距离，是出发地到目的地需要经过的城市个数。定义一个城市的交通便利值，为该城市到S国其他所有城市的距离。现在给你S国的交通网络，请你求出交通便利值最大的城市的编号。如果有多个，则输出编号最小的那个。
输入说明：
第一行有两个数N，M，城市个数和道路条数。
接下来M行，每行三个数，a，b，表示城市a与城市b有一条直接路径。
数据说明
50% N<=2000
100% N<=500000

Solution :
树上递推

Code :

/*************************************************************************
    > File Name: road.cpp
    > Author: Archer
 ************************************************************************/

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;

typedef long long ll;
typedef pair<int, int> PII;
#define REP(i, l, r) for (int i = l; i <= r; i++)
#define PER(i, r, l) for (int i = r; i >= l; i--)
#define MP make_pair
#define MS(_) memset(_, 0, sizeof(_))
#define fst first
#define sec second

const int N = 500100;
struct Node{int v; Node *nxt;}pool[N << 2], *tail = pool, *G[N];
ll sz[N], f[N], g[N], ans[N];
int n, m, fa[N], q[N];
inline void setIO(){
    freopen("road.in", "r", stdin);
    freopen("road.out", "w", stdout);
}
inline int read(){
    int x = 0, f = 1; char ch = getchar();
    while (!isdigit(ch)){if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    return f ? x : -x;
}
inline void addedge(int u, int v){
    tail->v = v; tail->nxt = G[u]; G[u] = tail++;
    tail->v = u; tail->nxt = G[v]; G[v] = tail++;
}
inline void bfs(){ int l, r, now;
    for (q[l = r = 1] = 1; l <= r; l++)
        for (Node *p = G[now = q[l]]; p; p = p->nxt)
            if (p->v != fa[now]) fa[q[++r] = p->v] = now;
}
inline void dp(){
    PER(i, n, 1) sz[q[i]]++, sz[fa[q[i]]] += sz[q[i]];
    PER(i, n, 1) 
        for (Node *p = G[q[i]]; p; p = p->nxt) if (p->v != fa[q[i]])
            f[q[i]] += f[p->v] + sz[p->v];
    REP(i, 2, n) g[q[i]] = f[fa[q[i]]] - (f[q[i]] + sz[q[i]]) + sz[fa[q[i]]] - sz[q[i]] + g[fa[q[i]]] + (n - sz[fa[q[i]]]);
    REP(i, 1, n) ans[q[i]] = f[q[i]] + g[q[i]]; 

    ll ret = 0; int k; 
    REP(i, 1, n) if (ans[i] > ret) {ret = ans[i]; k = i;}
    printf("%d\n", k);
}

int main(){
    setIO();

    n = read(); m = read();
    REP(i, 1, m) addedge(read(), read());
    bfs();
    dp();

    return 0;
}

题3：软件

问题描述：
一个软件开发公司同时要开发两个软件，并且要同时交付给用户，现在公司为了尽快完成这一任务，将每个软件划分成m个模块，由公司里的技术人员分工完成，每个技术人员完成同一软件的不同模块的所用的天数是相同的，并且是已知的，但完成不同软件的一个模块的时间是不同的，每个技术人员在同一时刻只能做一个模块，一个模块只能由一个人独立完成而不能由多人协同完成。一个技术人员在整个开发期内完成一个模块以后可以接着做任一软件的任一模块。写一个程序，求出公司最早能在什么时候交付软件。
输入说明：
输入文件第一行包含两个由空格隔开的整数n和m，其中1≤n≤100,1≤m≤100。
接下来的n行每行包含两个用空格隔开的整数d1和d2，d1表示该技术人员完成第一个软件中的一个模块所需的天数，d2表示该技术人员完成第二个软件中的一个模块所需的天数，其中1≤d1，d2≤100。
输出说明：
输出文件仅有一行包含一个整数d，表示公司最早能于d天后交付软件。

Solution :
二分+dp

Code :

/*************************************************************************
    > File Name: software.cpp
    > Author: Archer
 ************************************************************************/

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;

const int N = 111;
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef pair<int, int> PII;
#define REP(i, l, r) for (int i = l; i <= r; i++)
#define MP make_pair
#define MS(_) memset(_, 0, sizeof(_))
int n, m, a[N], b[N], dp[N][N];
inline void ckmax(int &a, int b){ a < b ? a = b : 1; }
inline void setIO(){
    freopen("software.in", "r", stdin);
    freopen("software.out", "w", stdout);
}
inline int read(){
    int x = 0, f = 1; char ch = getchar();
    while (!isdigit(ch)){if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    return f ? x : -x;
}
inline bool check(int T){
    REP(i, 0, n)REP（j, 0, m） dp[i][j] = -INF;
    dp[0][0] = 0;
    REP(i, 1, n) REP(k, 0, min(m, T / a[i])) REP(j, k, m)
        ckmax(dp[i][j], dp[i-1][j-k] + (T - a[i] * k)/b[i]);
    return dp[n][m] >= m;
}
int main(){
    setIO();

    n = read(); m = read();
    REP(i, 1, n) a[i] = read(), b[i] = read();

    int L = 0, R = 1000000;
    while (L + 1 < R){
        int mid = L+R >> 1;
        if (check(mid)) R = mid; else L = mid;
    }
    printf("%d\n", R);
    return 0;
}

题4：物流运输

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

输入说明：
第一行是四个整数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的运输路线。
输出说明：
一行仅一个整数表示最小的总成本。
总成本=n天运输路线长度之和+K*改变运输路线的次数。

Solution :
BZOJ1003

Code :

/*************************************************************************
    > File Name: trans.cpp
    > Author: Archer
 ************************************************************************/

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;

const int N = 222;
const int M = 33;
typedef long long ll;
typedef pair<pair<int, int>, int> PII;
#define INF 0x3f3f3f3f
#define REP(i, l, r) for (int i = l; i <= r; i++)
#define MP make_pair
#define MS(_) memset(_, 0, sizeof(_));
#define fst first
#define sec second

int n, m, k, e, d, dp[N], T[N][N], use[M][N], q[M], dis[M];
bool vis[M];
int g[M][M], g2[M][M];

inline void setIO(){
    freopen("trans.in", "r", stdin);
    freopen("trans.out", "w", stdout);
}
inline int read(){
    int x = 0, f = 1; char ch = getchar();
    while (!isdigit(ch)){if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
    return f ? x : -x;
}
inline int Dijsktra(int l,int r){ int now, mn;
    REP(i, 1, m) REP(j, 1, m) g2[i][j] = g[i][j];
    REP(i, 2, m - 1) REP(j, l, r)
        if(use[i][j]){ REP(k, 1, m) g2[i][k] = g2[k][i] = INF; break; }
    MS(vis);
    REP(i, 2, m) dis[i] = g2[1][i];
    REP(i, 2, m){
        mn = INF + 1; now = 0;
        REP(j, 2, m) if(!vis[j] && mn > dis[j]) mn = dis[j], now = j;
        vis[now] = 1;
        if(now == m) break;
        REP(j, 2, m) if(!vis[j]) dis[j] = min(dis[now] + g2[now][j], dis[j]);
    }
    return dis[m];
}
int main(){
    setIO();

    n = read(); m = read(); k = read(); e = read();
    REP(i, 1, m - 1) REP(j, i + 1, m) g[i][j] = g[j][i] = INF;
    REP(i, 1, e){
        int u = read(), v = read(), c = read();     
        g[u][v] = g[v][u] = min(c, g[u][v]);
    }
    d = read();
    REP(i, 1, d){
        int a = read(), b = read(), c = read();
        REP(j, b, c) use[a][j] = 1;
    }

    REP(i, 1, n) REP(j, i, n) T[i][j] = Dijsktra(i, j);
    REP(i, 1, n){       
        if(T[1][i] < INF) dp[i] = T[1][i] * i; else dp[i] = INF;
        REP(j, 1, i - 1)
           if(T[j + 1][i] < INF) dp[i] = min(dp[j] + k + T[j + 1][i] * (i - j), dp[i]);
    }
    printf("%d\n",dp[n]);

    return 0;
}