夏令营提高班上午上机测试 Day 2 解题报告

那一天，日照一中夏令营数据结构提高班的同学们终于想起了，被Day2上午的三道题支配的恐惧……
 
是的。。这一天的题有点难想。。
本来打算前天写这篇随笔，然而前天在机房和同学打luogu月赛……
昨天晚上写着写着睡着了。。GG
 
　　声明：标程全部来源于GTY哥哥，并非本人所写。
 
 
T1：债务
题目描述
小G有一群好朋友，他们经常互相借钱。假如说有三个好朋友A，B，C。A欠B20元，B欠C20元，总债务规模为20+20=40元。小G是个追求简约的人，他觉得这样的债务太繁杂了。他认为，上面的债务可以完全等价为A欠C20元，B既不欠别人，别人也不欠他。这样总债务规模就压缩到了 20 元。
现在给定n个人和m条债务关系。小G想找到一种新的债务方案，使得每个人欠钱的总数不变，或被欠钱的总数不变（但是对象可以发生变化），并且使得总债务规模最小。
输入格式
输入文件第一行两个数字 n, m，含义如题目所述。
接下来 m 行，每行三个数字 ai, bi, ci ，表示 ai欠 bi的钱数为 ci。
注意，数据中关于某两个人 A 和 B 的债务信息可能出现多次，将其累加即可。
如”A 欠 B 20 元”、”A 欠 B 30 元”、”B 欠 A 10 元”，其等价为”A 欠 B 40 元”。
输出格式
输出文件共一行，输出最小的总债务规模。
样例输入 1
5 3
1 2 10
2 3 1
2 4 1
样例输出 1
10
样例输入 2
4 3
1 2 1
2 3 1
3 1 1
样例输出 2
0
数据范围
对于 30% 的数据，1 ≤ n ≤ 10，1 ≤ m ≤ 10。
对于 60% 的数据，1 ≤ n ≤ 100, 1 ≤ m ≤ 104。
对于 80% 的数据，1 ≤ n ≤ 104，1 ≤ m ≤ 104。
对于 100% 的数据，1 ≤ n ≤ 106，1 ≤ m ≤ 106。
对于所有的数据，保证 1 ≤ ai, bi≤ n, 0 < ci≤ 100。
 
说简单点，就是让我们简化一下这些欠债和被欠债的关系，使得每个人欠钱或者被欠钱的总钱数不变，并且总债务之和最小。
这题在考场上想了好长时间，愣是没想出应该用什么做。。不过应该有一个结论能想出来：无论有多少欠钱和被欠钱的关系，债务规模应该是守恒的。这也就是说，我们优化之前和优化之后的债务规模应该是相等的。
我们设可能的最小债务规模为 总欠钱量/总被欠钱量，它应该被满足最优性和可行性才能作为一个最小债务规模。
通过画图模拟还钱的过程我们可以发现，无论我们怎样考虑等价债务关系，总会有一个方案，使得没有任何方案会比这个方案所等价出的债务规模更小。
同时我们发现，这应该是最小债务规模。如果债务规模还要比这更小，那钱根本就凑不齐，也就不符合题意了。
m只有10^6的规模 ，可以考虑O(m)去模拟这个过程。
我们假设每个人初始都有一定量的钱。
其实没必要非得给所有人加一些钱，初值为0就好。我们要计算的是等价到的债务而不是所有人具体有多少钱。
然后我们读入债务关系，如果a欠b c元钱，那么我们就模拟着让a去还给b c元钱，可以开一个数组记录w每个人初始拥有的钱数，每次读到a欠b c元，就让w[a]-=c,w[b]+=c，这样就完成了一次还钱。
全部操作完之后，也就是相当于所有人都对自己的债主还了钱之后，我们去统计每个人剩下的钱。
如果有人现在手里还剩下钱，那么统计这些钱的总值，这个值就是最小的债务规模。
这样做为什么正确？可能这样做有一点抽象，但它的确是对的。
想一下我们最初的目的，我们要统计的是最小的债务规模，而不用去关心到底要怎么去等价。如果有人把这个题想成一个图论题，那可能就gg了。　

　　

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <iostream>
using namespace std;

const int max_n = 1e6 + 10;
const int max_m = 1e6 + 10;
int a[max_n];

inline int getnum()
{
    int ans = 0; bool flag = false;
    char c;
    while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
    if (c == '-') flag = true;
    else ans = c - '0';
    while (isdigit(c = getchar()))
        ans = ans * 10 + c - '0';
    return ans;
}

int main()
{
    freopen("debt.in", "r", stdin);
    freopen("debt.out", "w", stdout);
    int n = getnum();
    int m = getnum();
    for (int i = 1; i <= m; i++)
    {
        int aa, bb, c;
        aa = getnum(); bb = getnum(); c = getnum();
        a[aa] += c; a[bb] -= c;
    }
    int ans = 0;
    for (int i = 1; i <= n; i++)
        if (a[i] > 0) ans += a[i];
    cout << ans << endl;
}

 

 
 
 
T2：排列
题目描述
小 G 喜欢玩排列。现在他手头有两个 n 的排列。n 的排列是由 0, 1, 2, ..., n − 1这 n 的数字组成的。对于一个排列 p，Order(p) 表示 p 是字典序第 Order(p) 小的排列（从 0 开始计数）。对于小于 n! 的非负数 x，Perm(x) 表示字典序第 x 小的排列。
现在，小 G 想求一下他手头两个排列的和。两个排列 p 和 q 的和为 sum = Perm((Order(p) + Order(q))%n!)。
输入格式
输入文件第一行一个数字 n，含义如题。
接下来两行，每行 n 个用空格隔开的数字，表示小 G 手头的两个排列。
输出格式 
输出一行 n 个数字，用空格隔开，表示两个排列的和。
样例输入 1
2
0 1
1 0
样例输出 1
1 0
样例输入 2
3
1 2 0
2 1 0
样例输出 2
1 0 2
数据范围
1、2、3、4 测试点，1 ≤ n ≤ 10。
5、6、7 测试点，1 ≤ n ≤ 5000，保证第二个排列的 Order ≤ 105。
8、9、10 测试点，1 ≤ n ≤ 5000。
 
Order和Perm可以理解为，他俩互为“反函数”。这句话怎么解释呢？Order(x)传入一个排列，返回的是这个排列的字典序。Perm(x)传入的是一个字典序的值，返回的值是一个排列。
暴力做法很简单，可以拿40分。
STL里头有一个algorithm头文件，里面有一个可以求全排列的函数next_premutation，那么我们根据题意去模拟这个过程就可以了。
那么我们该如何改进这个暴力做法呢？对于5,6,7测试点，数据范围给出了提示：保证第二个排列的Order≤10^5,我们可不可以以此为突破口进行探究呢？
当然可以！我们可以用next_permutaition计算出第二个排列的Order，然后对排列一做Order次next_permutaition，便可大大减少计算量。
你看，稍微一考虑，暴力就能拿70了，岂不是美滋滋。
好了，说正解。
很显然对于这道题，我们应该要尽量在O(n)的时间复杂度内求出一个排列的字典序的值。
我们设一个数组rank[n]，表示从n位置上的数字在a[1]~a[n]上的排名，从0开始计数。
然而n很大，我们算出来的Order也必定很大，所以直接计算是不可行的。
什么？高精度？。。。。你不嫌麻烦吗？
喂。。我只是说高精度麻烦，并不是说不让你们用啊喂！
怎么用？我觉得得稍微改改。具体的请参见代码。你可以将两个数相加，但不能将两个排列相加。所以我们可以把原先的排列转化为一个Rank数组，两个排列的Rank用一个类似高精度加法的方式相加。最后通过这个新的Rank数组就可以推出答案的排列。
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

const int max_n = 5e4 + 10;
int cnt[max_n], p1[max_n], p2[max_n], pp1[max_n], pp2[max_n], ans[max_n];
int n;

inline int getnum()
{
    int ans = 0; char c; bool flag = false;
    while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
    if (c == '-') flag = true; else ans = c - '0';
    while (isdigit(c = getchar())) ans = ans * 10 + c - '0';
    return ans * (flag ? -1 : 1);
}

int main()
{
    freopen("perm.in", "r", stdin);
    freopen("perm.out", "w", stdout);
    n = getnum();
    for (int i = n; i >= 1; i--) p1[i] = getnum();
    for (int i = n; i >= 1; i--) p2[i] = getnum();

    for (int i = 1; i <= n; i++)
        for (int j = 1; j < i; j++)
            if (p1[j] < p1[i]) pp1[i]++;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j < i; j++)
            if (p2[j] < p2[i]) pp2[i]++;
    
    for (int i = 2; i <= n; i++)
    {
        ans[i] += pp1[i] + pp2[i];
        ans[i + 1] += ans[i] / i;
        ans[i] %= i;
    }

    for (int i = n; i >= 1; i--)
    {
        int _ = -1;
        while (ans[i] >= 0)
        {
            _++;
            if (!cnt[_]) ans[i]--;
        }
        printf("%d ", _);
        cnt[_] = 1;
    }
}

 

 　　int _ ...你是真滴皮
 
T3：剪树枝
（据说做完题后，有同学在群里高呼“我要砍掉rzyz所有的苹果树！”
（这可能是我做的第一道树形DP题
（这段掐了别播
 

题目描述
rzyz 有一棵苹果树。苹果树有 n 个节点（也就是苹果），n − 1 条边（也就是树枝）。调皮的小 G 爬到苹果树上。他发现这棵苹果树上的苹果有两种：一种是黑苹果，一种是红苹果。小 G 想要剪掉 k 条树枝，将整棵树分成 k + 1 个部分。他想要保证每个部分里面有且仅有一个黑苹果。请问他一共有多少种剪树枝的方案？
输入格式
第一行一个数字 n，表示苹果树的节点（苹果）个数。
第二行一共 n − 1 个数字 p0, p1, p2, p3, ..., pn-2，pi 表示第 i + 1 个节点和 pi节点之间有一条边。注意，点的编号是 0 到 n − 1。
第三行一共 n 个数字 x0, x1 , x2 , x3 , ..., xn-1 。如果 x 是 1，表示 i 号节点是黑苹果；如果 x 是 0，表示 i 号节点是红苹果。
 
输出格式
输出一个数字，表示总方案数。答案对 109+ 7 取模。
样例输入 1
3
0 0
0 1 1
样例输出 1
2
样例输入 2
6
0 1 1 0 4
1 1 0 0 1 0
样例输出 2
1
样例输入 3
10
0 1 2 1 4 4 4 0 8
0 0 0 1 0 1 1 0 0 1
样例输出 3
27
数据范围
对于 30% 的数据，1 ≤ n ≤ 10。
对于 60% 的数据，1 ≤ n ≤ 100。
对于 80% 的数据，1 ≤ n ≤ 1000。
对于 100% 的数据，1 ≤ n ≤ 105。
对于所有数据点，都有 0 ≤ pi≤ n − 1，xi = 0 或 xi = 1。
特别地，60% 中、80% 中、100% 中各有一个点，树的形态是一条链。
 
noip式懵逼.jpg
如果不是正解告诉我要用树形DP做，我一定想不起来。。。
我直接按着课件上的思路说吧……我DP学瞎了。
我们先考虑暴力做法，搜索要删除的边，然后再检查每一部分是不是满足有且只有一个黑点。
正解是树上DP,也称树形DP。
既然是DP问题，那么我们就要考虑状态的转移。
影响我们转移的因素有哪些？
1.当前位于哪一棵子树
2.当前联通块中有没有黑苹果。
设dp[i][0]表示以i为根的这棵子树，最上面的那个联通块，没有黑点的方案数。dp[i][1]表示以i为根的子树，最上面那个联通块有一个黑点的方案数。
这样，初状态便是dp[i][0]=1,dp[i][1]=0。
对于每一个dp[i][1]，有两种情况：
    1. i点是黑色的，所有i的子树v和i相接，必须接dp[v][0]。
    2. i点是红色的，所有i的子树，有一棵接dp[v][1]，其余的接dp[v][0]。
对于dp[i][0]，有三种情况：
    1. i点是黑色的，所有i的子树v和i相接，必须接dp[v][0]，并且i上面的那条边得割断。
    2. i点是红色的，所有i的子树，有一棵接dp[v][1]，其余的接dp[v][0]，且i上面的那条边得割断。
    3. i点是红色的，所有i的子树v和i相接，都接dp[v][0]。
总体来说就分两种情况：
    1. 子树全都用dp[v][0]。
    2. 子树一棵用dp[v][1]，其余用dp[v][0]。
先用dp[i][0]存第一种情况，dp[i][1]存第二种情况
对于第一种情况，只需要把所有的dp[v][0]乘起来就可以了。
对于第二种情况，一种笨办法是枚举哪一个是dp[v][1]，然后再乘上其余的dp[v][0]。这样的话效率最坏到O(n2)。
#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <iostream>
using namespace std;

#define ll long long
const int MAXN = 1e5 + 10;
const int MOD  = 1e9 + 7;

ll f[MAXN][2];
int point[MAXN] = {0}, nxt[MAXN * 2] = {0}, v[MAXN * 2] = {0}, tot = 0;
bool color[MAXN] = {0};
int n;

inline void addedge(int x, int y)
{
    tot++;
    nxt[tot] = point[x]; point[x] = tot; v[tot] = y;
}

void dfs(int now, int father)
{
    f[now][0] = 1;
    f[now][1] = 0;
    for (int tmp = point[now]; tmp; tmp = nxt[tmp])
        if (v[tmp] != father)
        {
            dfs(v[tmp], now);
            f[now][1] = (f[now][1] * f[v[tmp]][0]) % MOD;
            f[now][1] = (f[now][1] + f[now][0] * f[v[tmp]][1]) % MOD;
            f[now][0] = (f[now][0] * f[v[tmp]][0]) % MOD;
        }
    if (color[now])
        f[now][1] = f[now][0];
    else
        f[now][0] = (f[now][0] + f[now][1]) % MOD;
}

int main()
{
    freopen("tree.in", "r", stdin);
    freopen("tree.out", "w", stdout);
    scanf("%d", &n);
    for (int i = 2; i <= n; i++)
    {
        int x;
        scanf("%d", &x);
        addedge(i, x + 1); addedge(x + 1, i);
    }
    for (int i = 1; i <= n; i++)
    {
        int x;
        scanf("%d", &x);
        if (x == 1) color[i] = true;
        else color[i] = false;
    }
    dfs(1, 0);
    cout << f[1][1] << endl;
}

 

 
 
啊。。如果有哪位大佬能想出T3更好的解释方法的话请在评论区留言或者私信我，本蒟蒻表示不胜感激。。
 
posted @ 2017-08-07 13:54  ShawnZhou_Aether  阅读(558)  评论(0)  编辑  收藏  举报