HPUACM大二周练第二周

最新推荐文章于 2018-07-01 23:28:39 发布

ctsas

最新推荐文章于 2018-07-01 23:28:39 发布

阅读量387

点赞数

分类专栏：题解 hash 最大流字典树 spfa

本文链接：https://blog.csdn.net/ctsas/article/details/78153137

版权

最大流同时被 3 个专栏收录

8 篇文章 0 订阅

订阅专栏

题解

7 篇文章 0 订阅

订阅专栏

字典树

3 篇文章 0 订阅

订阅专栏

URL ：https://vjudge.net/contest/188110

A

先把它看成一条链状的树，然后考虑加边，最后发现公式：

a n s = n - 1 + \sum i = 4 n [i - 2 2]

$ans=n-1+\sum_{i=4}^n{[\frac{i-2}{2}]}$

$O(n)$ 。没有继续对这个公式化简了，理论上是可以得到一个直接的通项公式。

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<cmath>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;

void slove() {
    int n, ans;
    scanf("%d", &n);
    ans = n - 1;
    for(int i = 4; i <= n; ++i) {
        ans += (i - 2) / 2;
    }
    printf("%d\n", ans);
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--) {
        slove();
    }
    return 0;
}

B

提供一组数据：
input
1
10 10 18
2 3 3
output
56

$O(n)$

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<cmath>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;

typedef  long long LL;
LL cnt[3], d[3], best;

int main()
{
    int T;
    scanf("%d", &T);
    while(T--) {
        for(int i = 0; i < 3; ++i) {
            scanf("%I64d", cnt + i);
        }
        for(int i = 0; i < 3; ++i) {
            scanf("%I64d", d + i);
        }
        best = 0;
        LL mi = min(cnt[0], cnt[1]);
        for(int i = 0; i <= mi; ++i) {
            LL tmp_ans = i * d[0];
            LL mi_ac = min(cnt[0] - i, cnt[2]);
            LL mi_ac_bc = min(cnt[1] - i, cnt[2] - mi_ac);
            LL mi_bc = min(cnt[1] - i, cnt[2]);
            LL mi_bc_ac = min(cnt[0] - i, cnt[2] - mi_bc);
            tmp_ans += max(mi_ac * d[1] + mi_ac_bc * d[2], mi_bc * d[2] + mi_bc_ac * d[1]);
            best = max(tmp_ans, best);
        }
        printf("%I64d\n", best);
    }
    return 0;
}

C

1# 发现 $O(n^3)$ 的dp是刚好过不去的

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#pragma GCC optimize ("O2")
#include<stdio.h>
const int MAXN = 605;
int dp[2][MAXN][MAXN], arr[MAXN][MAXN], n;

inline void read(int &x) {
    char c;
    while((c = getchar()) <= 32);
    for(x = 0; c >= '0'; c = getchar()) x = x * 10 + c - '0';
}
inline int max(int x, int y) { return x > y ? x : y; }
void slove() {
    int top = n * 2 - 2;
    for(int i = 0; i <= n; ++i) for(int j = 0; j <= n; ++j) dp[0][i][j] = dp[1][i][j] = 0;
    dp[0][1][1] = arr[1][1];
    for(int s = 1; s < top; ++s) {
        for(int i = max(s - n + 2, 1); s - i + 2 > 0; ++i) {
            for(int j = max(s - n + 2, 1); s - j + 2 > 0; ++j) {
                if(i == j) continue ;
                dp[s&1][i][j] = max(max(dp[~s&1][i][j], dp[~s&1][i - 1][j]) , max(dp[~s&1][i][j - 1], dp[~s&1][i - 1][j - 1])) + arr[s - i + 2][i] + arr[s - j + 2][j];
            }
        }
    }
    int ans = max(max(dp[~top&1][n][n], dp[~top&1][n - 1][n]) , max(dp[~top&1][n][n - 1], dp[~top&1][n - 1][n - 1])) + arr[n][n];
    printf("%d\n", ans);
}

int main()
{
    while(scanf("%d", &n) != EOF) {
        for(int i = 1; i <= n; ++i) {
            for(int j = 1; j <= n; ++j) {
                read(arr[i][j]);
            }
        }
        slove();
    }
    return 0;
}

2# 费用关键就是建图，Bellman-Ford 算法会超时的用SPFA 或 Dijkstra

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#pragma GCC optimize ("O2")
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;

inline void read(int &x) {
    char c;while((c = getchar()) <= 32);
    for(x = 0; c >= '0'; c = getchar()) x = x * 10 + c - '0';
}
const int MAXN = 1005;
struct edge {
    int to, cap, cost, next;
    edge() {}
    edge(int _to, int _cap, int _cost, int _next) {to = _to, cost = _cost, cap = _cap, next = _next;}
} E[MAXN * MAXN * 6];

int head[MAXN * MAXN * 2], tot;
inline void add_edge(int u, int v, int cap, int cost) {
    E[tot] = edge(v, cap, cost, head[u]);
    head[u] = tot++;
    E[tot] = edge(u, 0 , -cost, head[v]);
    head[v] = tot++;
}

int arr[MAXN][MAXN], n, s, t, Z;

void init() {
    s = 0, t = n * n * 2 - 1, Z = n * n;
    for(int i = 0; i < n; ++i) {
        for(int j = 0; j < n; ++j) {
            int o = i * n + j;
            if(o == 0 || o == Z - 1) {
                add_edge(o, o + Z, 2, arr[i][j]);
            } else {
                add_edge(o, o + Z, 1, arr[i][j]);
            }
            if(j + 1 < n) {
                add_edge(o + Z, o + 1, 1, 0);
            }
            if(i + 1 < n) {
                add_edge(o + Z, o + n, 1, 0);
            }
        }
    }
}

int dist[MAXN * MAXN * 2], pre[MAXN * MAXN * 2];
queue<int> que;
int max_cost_flow(int f) {
    int res = 0;
    while(f > 0) {
        memset(dist, 0x8f, n * n * 2 * sizeof(int));
        dist[s] = 0;
        /*
        bool update = true;
        while(update) {
            update = false;
            for(int v = 0; v <= t; ++v) {
                for(int i = head[v]; ~i; i = E[i].next) {
                    edge &e = E[i];
                    if(e.cap > 0 && dist[e.to] < dist[v] + e.cost) {
                        dist[e.to] = dist[v] + e.cost;
                        pre[e.to] = i;
                        update = true;
                    }
                }
            }
        }*/
        que.push(s);
        while(!que.empty()) {
            int v = que.front(); que.pop();
            for(int i = head[v]; ~i; i = E[i].next) {
                edge &e = E[i];
                if(e.cap > 0 && dist[e.to] < dist[v] + e.cost) {
                    dist[e.to] = dist[v] + e.cost;
                    pre[e.to] = i;
                    que.push(e.to);
                }
            }
        }
        if(dist[t] == 0x8f8f8f8f) {
            break ;
        }
        int d = f;
        for(int v = t; v != s; v = E[pre[v]^1].to) {
            d = min(d, E[pre[v]].cap);
        }
        f -= d;
        res += d * dist[t];
        for(int v = t; v != s; v = E[pre[v]^1].to) {
            E[pre[v]  ].cap -= d;
            E[pre[v]^1].cap += d;
        }
    }
    return res - arr[0][0] - arr[n - 1][n - 1];
}

int main()
{
    while(scanf("%d", &n) != EOF) {
        memset(head, 0xff, sizeof head);
        tot = 0;
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < n; ++j) {
                read(arr[i][j]);
            }
        }
        init();
        int ans = max_cost_flow(2);
        printf("%d\n", ans);
    }
    return 0;
}

D

发现这个题和“最多重叠区间个数”有联系，并且转化后就是在求“重叠区间个数*重叠区间长度”的最大值。
暴力出奇迹。本来想用数据结构去优化的，但是发现还不如暴力实在。

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;

char s[5000 + 5];
int mp[5005][5005], n, m, tot = 0;

void get() {
    for(int i = 0; i < m; ++i) {
        if(s[i] == '1') {
            int j = i;
            while(j < m && s[j] == '1') ++j; --j;
            for(int k = i; k <= j; ++k) ++mp[k][j];
            i = j;
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; ++i) {
        scanf("%s", s);
        get();
    }
    int ans = 0;
    for(int i = 0; i < m; ++i) {
        int num = 0;
        for(int j = m - 1; j >= i; --j) {
            num += mp[i][j];
            ans = max(ans, (j - i + 1) * num);
        }
    }
    printf("%d\n", ans);
    return 0;
}

E

考虑一个面的时候，我们要看到它数学意义的外曲面，那么我只有在它的正方向上即可。对六个面分别考虑即可。

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

int main()
{
    int a[12];
    for(int i = 0; i < 12; ++i) {
        scanf("%d", a + i);
    }
    int ans = 0;
    if(a[0] < 0) ans += a[5 + 5];
    if(a[1] < 0) ans += a[5 + 1];
    if(a[2] < 0) ans += a[5 + 3];
    if(a[0] > a[3]) ans += a[5 + 6];
    if(a[1] > a[4]) ans += a[5 + 2];
    if(a[2] > a[5]) ans += a[5 + 4];
    printf("%d\n", ans);
    return 0;
}

F

无语啊字典树超内存，然后写了哈希。输入是这个题的“亮点”。

1# 字典树 $O(n \cdot len + Q\cdot len)$

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<cmath>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;

char s[12];

struct node {
    int cnt;
    node *ch[26];
    node() {cnt = 1;for(int i = 0; i < 26; ++i) ch[i] = NULL;}
} root;

void add() {
    node *z  = &root;
    int d = 0;
    ++z->cnt;
    while(z != NULL && s[d] != '\0') {
        int u = s[d++] - 'a';
        if(z->ch[u] == NULL) {
            z->ch[u] = new node();
            z = z->ch[u];
        } else {
            z = z->ch[u];
            ++z->cnt;
        }
    }
}

int query() {
    node *z = &root;
    int d = 0;
    while(z != NULL && s[d] != '\0') {
        int u = s[d++] - 'a';
        if(z->ch[u] == NULL) return 0;
        z = z->ch[u];
    }
    return z == NULL ? 0 : z->cnt;
}

int main()
{
//    freopen("/Users/neo/Desktop/in", "r", stdin);
    root.cnt = 0;
    while(scanf("%c", &s[0]) && s[0] != '\n') {
        int t = 1;
        while(scanf("%c", &s[t]) && s[t] != '\n') ++t;
        s[t] = '\0';
        add();
//        puts(s);
    }
    while(scanf("%s", s) != EOF) {
        printf("%d\n", query());
    }
    return 0;
}

2# 哈希+map $O(len\cdot n+(Q + n)\cdot len\cdot \log n)$

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<cmath>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;

typedef unsigned long long ull;
const ull MOD = 1000000009;

char s[100];

map<ull, int> mp;
ull hhash(int op) {
    ull res = 1;
    for(int i = 0; s[i]; ++i) {
        res *= MOD;
        res += s[i];
        if(op) ++mp[res];
    }
    return res;
}

int main()
{
//    freopen("/Users/neo/Desktop/in", "r", stdin);
    mp.clear();
    while(scanf("%c", &s[0]) && s[0] != '\n') {
        int t = 1;
        while(scanf("%c", &s[t]) && s[t] != '\n') ++t;
        s[t] = '\0';
        hhash(1);
    }
    while(scanf("%s", s) != EOF) {
        printf("%d\n", mp[hhash(0)]);
    }
    return 0;
}

G

LCA。这是个单纯的暴力题了，本来想出找一个有技巧一点的。 $O(n)$

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int MAXN = 10005;
struct Edge {int to, next;} E[MAXN];
int head[MAXN], cnt[MAXN], deep[MAXN], par[MAXN], tot, n;
void add_edge(int u, int v) {
    E[tot].to = v;
    E[tot].next = head[u];
    head[u] = tot++;
}
void dfs(int u, int fa) {
    par[u] = fa;
    deep[u] = deep[fa] + 1;
    for(int i = head[u]; ~i; i = E[i].next) {
        int &v = E[i].to;
        if(v == fa) continue;
        dfs(v, u);
    }
}

int main()
{
    int T, x, y;;
    scanf("%d", &T);
    while(T--) {
        memset(head, 0xff, sizeof head);
        memset(cnt , 0x00, sizeof cnt );
        tot = 0;
        scanf("%d", &n);
        for(int i = 1; i < n; ++i) {
            scanf("%d%d", &x, &y);
            add_edge(x, y);
            ++cnt[y];
        }
        int root;
        for(int i = 1; ; ++i) {
            if(cnt[i] == 0) {
                root = i;
                break;
            }
        }
        dfs(root, 0);
        scanf("%d%d", &x, &y);
        while(deep[x] > deep[y]) x = par[x];
        while(deep[y] > deep[x]) y = par[y];
        while(x != y) x = par[x],y = par[y];
        printf("%d\n", x);
    }
    return 0;
}

H

让操作最少得到最多重复的，肯定是要找连续的一段数。我们先排序，再枚举起点，二分找终点。 $O(n\log n)$

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

typedef long long LL;
const int MAXN = 100005;
int arr[MAXN], n, k;
LL sum[MAXN];

void slove() {
    int ans = 0, who = 0;
    for(int i = 1; i <= n; ++i) {
        int low = i, top = n + 1;
        while(top - low > 1) {
            int mid = (low + top) >> 1;
            LL res = 1LL * (mid - i + 1) * arr[mid] - (sum[mid] -  sum[i - 1]);
            if(res > k) top = mid;
            else low = mid;
        }
        if(low - i + 1 > ans) {
            ans = low - i + 1;
            who = arr[low];
        }
    }
    printf("%d %d\n", ans, who);
}

int main()
{
    while(scanf("%d%d", &n, &k) != EOF) {
        for(int i = 1; i <= n; ++i) {
            scanf("%d", arr + i);
        }
        sort(arr + 1, arr + 1 + n);
        for(int i = 1; i <= n; ++i) {
            sum[i] = sum[i - 1] + arr[i];
        }
        slove();
    }
    return 0;
}

J

树链剖分 $O(n + n\cdot \log n + Q\cdot \log ^2n)$

//  Created by chutzpah on 2017/10/2.
//  Copyright © 2017年 chutzpah. All rights reserved.
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int MAXN = 50005;
int n, m, Q;
int val[MAXN];
struct Edge {int to, next;} E[MAXN<<1];
int head[MAXN], tot;
void add_edge(int u, int v) {
    E[tot].to = v;
    E[tot].next = head[u];
    head[u] = tot++;
}
int par[MAXN], son[MAXN], deep[MAXN], cnt[MAXN];
void dfs(int u, int fa) {
    par[u] = fa;
    deep[u] = deep[fa] + 1;
    cnt[u] = 1;
    son[u] = -1;
    for(int i = head[u]; ~i; i = E[i].next) {
        int &v = E[i].to;
        if(v == fa) continue;
        dfs(v, u);
        cnt[u] += cnt[v];
        if(son[u] == -1 || cnt[v] > cnt[son[u]]) son[u] = v;
    }
}
int top[MAXN], pos, p[MAXN], fp[MAXN];
void ggp(int u, int sp) {
    top[u] = sp;
    p[u] = pos++;
    fp[p[u]] = u;
    if(son[u] == -1) return ;
    ggp(son[u], sp);
    for(int i = head[u]; ~i; i = E[i].next) {
        int &v = E[i].to;
        if(v == par[u]) continue;
        if(v != son[u]) ggp(v, v);
    }
}
int c[MAXN];
void add(int v, int x) {
    while(v <= n) {
        c[v] += x;
        v += v&(-v);
    }
}
int sum(int v) {
    int res = 0;
    while(v > 0) {
        res += c[v];
        v -= v&(-v);
    }
    return res;
}
void change(int u, int v, int _val) {
    int f1 = top[u], f2 = top[v];
    while(f1 != f2) {
        if(deep[f1] < deep[f2]) {
            swap(f1, f2);
            swap(u, v);
        }
        add(p[f1], _val);
        add(p[u] + 1, -_val);
        u = par[f1];
        f1 = top[u];
    }
    if(deep[u] > deep[v]) swap(u, v);
    add(p[u], _val);
    add(p[v] + 1, -_val);
}
int main()
{
    while(scanf("%d%d%d", &n, &m, &Q) != EOF) {
        memset(head, 0xff, sizeof head);
        memset(c   , 0x00, sizeof c   );
        tot = 0;
        pos = 1;

        for(int i = 1; i <= n; ++i) {
            scanf("%d", val + i);
        }
        for(int i = 0; i < m; ++i) {
            int x, y;
            scanf("%d%d", &x, &y);
            add_edge(x, y);
            add_edge(y, x);
        }
        dfs(1, 0);
        ggp(1, 1);
        for(int i = 1; i <= n; ++i) {
            add(p[i], val[i]);
            add(p[i] + 1, -val[i]);
        }
        while(Q--) {
            char op;
            scanf("\n%c", &op);
            if(op == 'Q') {
                int u;
                scanf("%d", &u);
                printf("%d\n", sum(p[u]));
            } else {
                int x, y, v;
                scanf("%d%d%d", &x, &y, &v);
                change(x, y, op == 'D' ? -v : v);
            }
        }
    }
    return 0;
}