PAT L3-017. 森森快递

L3-017. 森森快递

时间限制

400 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

俞勇（上海交通大学）

森森开了一家快递公司，叫森森快递。因为公司刚刚开张，所以业务路线很简单，可以认为是一条直线上的N个城市，这些城市从左到右依次从0到(N-1)编号。由于道路限制，第i号城市（i=0, ..., N-2）与第(i+1)号城市中间往返的运输货物重量在同一时刻不能超过 C_i公斤。

公司开张后很快接到了Q张订单，其中第j张订单描述了某些指定的货物要从S_j号城市运输到T_j号城市。这里我们简单地假设所有货物都有无限货源，森森会不定时地挑选其中一部分货物进行运输。安全起见，这些货物不会在中途卸货。

为了让公司整体效益更佳，森森想知道如何安排订单的运输，能使得运输的货物重量最大且符合道路的限制？要注意的是，发货时间有可能是任何时刻，所以我们安排订单的时候，必须保证共用同一条道路的所有货车的总重量不超载。例如我们安排1号城市到4号城市以及2号城市到4号城市两张订单的运输，则这两张订单的运输同时受2-3以及3-4两条道路的限制，因为两张订单的货物可能会同时在这些道路上运输。

输入格式：

输入在第一行给出两个正整数N和Q（2 <= N <= 10⁵, 1 <= Q <= 10⁵），表示总共的城市数以及订单数量。

第二行给出(N-1)个数，顺次表示相邻两城市间的道路允许的最大运货重量C_i（i=0, ..., N-2）。题目保证每个C_i是不超过2³¹的非负整数。

接下来Q行，每行给出一张订单的起始及终止运输城市编号。题目保证所有编号合法，并且不存在起点和终点重合的情况。

输出格式：

在一行中输出可运输货物的最大重量。

输入样例：

10 6
0 7 8 5 2 3 1 9 10
0 9
1 8
2 7
6 3
4 5
4 2

输出样例：

7

样例提示：我们选择执行最后两张订单，即把5公斤货从城市4运到城市2，并且把2公斤货从城市4运到城市5，就可以得到最大运输量7公斤。

 

用dfs水了15分，开始用wector做的，以为vector< pair<int,int> >E[maxn] 定义，可以直接通过E[x][y]访问(x,y)边，写的差不多以后才发现不可以，每次增加是从零开始的，比如在1点添加5，6，你只能通过E[1][0],E[1][1]一次访问(1,0),(1,1)边。最后两分钟情急下用了数组水了15分

 

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<map>
#include<set>
#define maxn 10010
using namespace std;
typedef long long ll;
int edge[maxn][maxn];
vector<int> E[maxn];
ll ans = 0;
int vis[maxn] = {0};
void dfs( int x, ll sum ) {
    if( sum > ans ) {
        ans = sum;
    }
    for( int i = 0; i < E[x].size(); i ++ ) {
        if( !vis[E[x][i]] ) {
            vis[E[x][i]] = 1;
            dfs( E[x][i], sum + edge[x][E[x][i]] );
            vis[E[x][i]] = 0;
        }
    }
}
int main() {
    int n, m, a[maxn], t = 1e9;
    cin >> n >> m;
    for( int i = 0; i < n - 1; i ++ ) {
        cin >> a[i];
       /* edge[i].push_back( make_pair( i + 1, a[i] ) );
        edge[i+1].push_back( make_pair( i, a[i] ) );*/
        edge[i][i+1] = a[i];
        edge[i+1][i] = a[i];
        for( int j = 0; j < i - 1; j ++ ) {
            t = 1e9;
            for( int k = j; k < i; k ++ ) {
                t = min( t, a[k] );
            }
            /*edge[j].push_back( make_pair( i, t ) );
            edge[i].push_back( make_pair( j, t ) );*/
            edge[i][j] = t;
            edge[j][i] = t;
        }
    }
    while( m -- ) {
        int x, y;
        cin >> x >> y;
        E[x].push_back(y);
        E[y].push_back(x);
    }
    for( int i = 0; i <= n - 1; i ++ ) {
        /*for( int j = 0; j < E[i].size(); j ++ ) {
            cout << E[i][j] << " " << edge[i][E[i][j]] << "--";
        }
        cout << endl;*/
        memset( vis, 0, sizeof(vis) );
        vis[i] = 1;
        dfs( i, 0 );
    }
    cout << ans - 1 << endl;
    return 0;
}

比赛后看大佬用线段树+贪心做的

https://blog.csdn.net/hnust_derker/article/details/79552988

/** 
因为一个区间[l, r]的最大货运量就是min([l, r])， 对于两个区间[l, r], [L, R] 假设(r <= R) 
1. 两个区间完全不相交， 则最大货运量就是min([l, r]) + min([L, R])，谁先取谁后取都是一样 
 
2.[l, r]完全包含于[L, R]，那么肯定选择[l, r]且取其最大货运量，因为min[l, r] >= min[L, R]，如果选择两个订单的话，最大货运量都 
是min[l, r]， 但是单独取[l, r]这个区间， 那么对周围影响的区间都小， 往左往右才可能有更优的取值， 如果[L, R]这个区间要取的话， 
这里的每个值都要减去一个值，且最终[l, r]的结果是一样的， 所以肯定取[l,r]且保证货运量最大 
 
3.两区间相交，如果若干个区间已经按右端点从小到大排好序，相同按左端点排序，假设相交于[L, r]， 那么两个区间的最大值就是 
min{min[L, r], min[l, r] + min[L, R]}这个值是不变的，但是如果[L, R]取得大的话， 对后面的可能相交区间最小值影响就大， 所以要对 
l, r取尽可能大， L, R取尽可能小 
 
所以就是： 区间已经按右端点从小到大排好序，相同按左端点排序， 然后从左往右，遇到一个区间就取其区间最小值加到ans上去， 然后更新这个区间 
*/  
  
#include<bits/stdc++.h>  
typedef long long ll;  
const ll maxn = 2e5 + 10;  
const ll INF = 1e10;  
using namespace std;  
  
  
typedef pair<ll, ll> pa;  
ll n, m, T, kase = 1;  
ll C[maxn * 4], lazy[maxn * 4], d[maxn];  
pa lst[maxn];  
  
void push_down(ll o) {  
    ll o1 = o << 1, o2 = o << 1 | 1;  
    if(!lazy[o]) return ;  
    lazy[o1] += lazy[o]; lazy[o2] += lazy[o];  
    C[o1] -= lazy[o]; C[o2] -= lazy[o]; lazy[o] = 0;  
}  
  
void build(ll o, ll l, ll r) {  
    lazy[o] = 0;  
    if(l == r) { C[o] = d[l]; return ; }  
    ll mid = (l + r) >> 1;  
    build(o << 1, l, mid);  
    build(o << 1 | 1, mid + 1, r);  
    C[o] = min(C[o << 1], C[o << 1 | 1]);  
}  
  
ll ql, qr, data;  
ll query_min(ll o, ll l, ll r) {  
    if(l >= ql && r <= qr) return C[o];  
    if(l > qr || r < ql) return INF;  
    ll mid = (l + r) >> 1;  
    push_down(o);  
    ll p1 = query_min(o << 1, l, mid);  
    ll p2 = query_min(o << 1 | 1, mid + 1, r);  
    C[o] = min(C[o << 1], C[o << 1 | 1]);  
    return min(p1, p2);  
}  
  
void update(ll o, ll l, ll r) {  
    if(l >= ql && r <= qr) {  
        C[o] -= data; lazy[o] += data;  
        return ;  
    }  
    if(l > qr || r < ql) return ;  
    push_down(o);  
    ll mid = (l + r) >> 1;  
    update(o << 1, l, mid);  
    update(o << 1 | 1, mid + 1, r);  
    C[o] = min(C[o << 1], C[o << 1 | 1]);  
}  
  
int main() {  
    while(scanf("%lld %lld", &n, &m) != EOF) {  
        for(ll i = 0; i < n - 1; i++) scanf("%lld", &d[i]);  
        build(1, 0, n - 2);  
        for(ll i = 0; i < m; i++) {  
            scanf("%lld %lld", &ql, &qr);  
            if(ql > qr) swap(ql, qr); qr--;  
            lst[i] = pa(qr, ql);  
        }  
        ll ans = 0; sort(lst, lst + m);  
        for(int i = 0; i < m; i++) {  
            ql = lst[i].second; qr = lst[i].first;  
            ll mt = query_min(1, 0, n - 2);  
            ans += mt; data = mt; update(1, 0, n - 2);  
        }  
        printf("%lld
", ans);  
    }  
    return 0;  
}