8.22 NOIP 模拟题
8.22 NOIP 模拟题
编译命令 g++ -o * *.cpp gcc -o * *.c fpc *.pas 编译器版本 g++/gcc 4.9.2 fpc 2.6.2 评测环境 64 位 Linux, 3.3GHZ CPU 评测软件 Lemon 评测方式 忽略行末空格和回车 特别注意：c/c++ 选手使用 printf 输出 64 位整数请使用%lld 1
A 债务
文件名 输入文件 输出文件 时空限制
debt.pas/c/cpp debt.in debt.out 1s 128MB
题目描述
小 G 有一群好朋友，他们经常互相借钱。假如说有三个好朋友 A，B，C。A
欠 B 20 元，B 欠 C 20 元，总债务规模为 20+20=40 元。小 G 是个追求简约的人，
他觉得这样的债务太繁杂了。他认为，上面的债务可以完全等价为 A 欠 C 20 元，
B 既不欠别人，别人也不欠他。这样总债务规模就压缩到了 20 元。
现在给定 n 个人和 m 条债务关系。小 G 想找到一种新的债务方案，使得每个
人欠钱的总数不变，或被欠钱的总数不变（但是对象可以发生变化） ，并且使得总
债务规模最小。
输入格式
输入文件第一行两个数字 n,m，含义如题目所述。
接下来 m 行，每行三个数字 a i ,b i ,c i ，表示 a i 欠 b i 的钱数为 c i 。
注意，数据中关于某两个人 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
2
样例输出 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 ≤ 10 4 。
对于 80% 的数据，1 ≤ n ≤ 10 4 ，1 ≤ m ≤ 10 4 。
对于 100% 的数据，1 ≤ n ≤ 10 6 ，1 ≤ m ≤ 10 6 。
对于所有的数据，保证 1 ≤ a i ,b i ≤ n,0 < c i ≤ 100。
#include<iostream> #include<cstdio> #include<cstring> #define N 1000007 using namespace std; int val[N]; int x,y,z,n,m,ans; inline int read() { int x=0,f=1;char c=getchar(); while(c>'9'||c<'0'){if(c=='-')f=-1;c=getchar();} while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();} return x*f; } int main() { freopen("debt.in","r",stdin); freopen("debt.out","w",stdout); n=read(),m=read(); for(int i=1;i<=m;i++) { x=read();y=read();z=read(); val[y]+=z;val[x]-=z; } for(int i=1;i<=n;i++) if(val[i]<0) ans+=-val[i]; printf("%d\n",ans); fclose(stdin);fclose(stdout); return 0; }
B 排列
文件名 输入文件 输出文件 时空限制
perm.pas/c/cpp perm.in perm.out 1s 128MB
题目描述
小 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
4
样例输入 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 ≤ 10 5 。
8、9、10 测试点，1 ≤ n ≤ 5000。
/* 可以看出Order perm 互为反函数 康托展开： 一个序列的排名(从0开始计数) = Rank[n]*(n-1)!+Rank[n-1]*(n-2)!+…. 其中Rank[n]表示n位置上的数字在a[1]~a[n]中的排行，并且从0开始计数。 先求出两个序列的康托展开式，相加 但是显然阶乘爆掉 于是我们只加rank数组 如果rank[i]这一位大于等于i，就按i进制进位 证明： ……rank[i] * (i - 1) ! + rank[i + 1] * i !…… 若rank[i] > i 那么可分解为 rank[i]%i * (i - 1)! + rank[i]/i * i! + rank[i + 1]*i! 所以进位显然 mod n!的话，只需要忽略rank[i + 1]即可 可以从n往前找，p从-1向上累计，遇到没有用过的p就标记为用过，同时rank[n]-- 因为num[i + 1..n]求出后能得知num[i]能选哪一些数 也就是num[1...i]有哪一些数 从小到大枚举到对应排名即可 */ #include<iostream> #include<cstdio> #include<cstring> #define N 6010 #define inf 0x3f3f3f3f using namespace std; int num1[N],num2[N],rank[N],rank2[N]; int n,b[N]; int main() { freopen("perm.in","r",stdin); freopen("perm.out","w",stdout); scanf("%d",&n); for(int i=n;i>0;i--) scanf("%d",&num1[i]); for(int i=n;i>0;i--) scanf("%d",&num2[i]); int p; for(int i=1;i<=n;i++) { p=0; for(int j=1;j<i;j++) if(num1[j]<num1[i]) ++p; rank[i]+=p; p=0; for(int j=1;j<i;j++) if(num2[j]<num2[i]) ++p; rank2[i]+=p; rank[i]+=rank2[i]; rank[i+1]+=rank[i]/i; rank[i]%=i; } rank[n]%=n; for(int i=n;i>=1;i--) { p=-1; while(rank[i]>=0) { ++p; if(!b[p]) --rank[i]; }b[p]=1; printf("%d ",p); }return 0; }
C 剪树枝
文件名 输入文件 输出文件 时空限制
tree.pas/c/cpp tree.in tree.out 1s 128MB
题目描述
rzyz 有一棵苹果树。苹果树有 n 个节点（也就是苹果） ，n − 1 条边（也就是
树枝） 。调皮的小 G 爬到苹果树上。他发现这棵苹果树上的苹果有两种：一种是黑
苹果，一种是红苹果。小 G 想要剪掉 k 条树枝，将整棵树分成 k + 1 个部分。他
想要保证每个部分里面有且仅有一个黑苹果。请问他一共有多少种剪树枝的方案？
输入格式
第一行一个数字 n，表示苹果树的节点（苹果）个数。
第二行一共 n − 1 个数字 p 0 ,p 1 ,p 2 ,p 3 ,...,p n−2 ，p i 表示第 i + 1 个节点和 p i 节
点之间有一条边。注意，点的编号是 0 到 n − 1。
第三行一共 n 个数字 x 0 ,x 1 ,x 2 ,x 3 ,...,x n−1 。如果 x i 是 1，表示 i 号节点是黑
苹果；如果 x i 是 0，表示 i 号节点是红苹果。
输出格式
输出一个数字，表示总方案数。 答案对 10 9 + 7 取模。
样例输入 1
3
0 0
0 1 1
样例输出 1
2
6
样例输入 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 ≤ 10 5 。
对于所有数据点，都有 0 ≤ p i ≤ n − 1，x i = 0 或 x i = 1。
特别地，60% 中、80% 中、100% 中各有一个点，树的形态是一条链。
/* 一道比价杂乱的树形dp，但貌似很经典。 f[i][0][0]代表第i个点是否砍掉，以它为根的子树中有没有黑点。 转移的时候判断当前点是黑是红 黑点：f[u][1][0]=0;f[u][0][0]=0;（这两种情况不成立，不管砍不砍以它为根的子树中一定有黑点） f[u][1][1]=f[v][1][1]+f[v][0][0]的乘积（它被砍了子树中只能有它一个黑点， 所以儿子中要么没有黑点[0][0]要么有黑点被砍了[1][1]） f[u][0][1]不知道暂时赋值为f[u][1][1] 白点：f[u][1][0]这种情况对答案没有贡献设为0，因为它为白点子树仍为白点都不能割； f[u][0][0]=f[v][1][1]+f[v][0][0]的乘积 （它的子树中没有黑点，儿子中要么没有黑点[0][0]要么有黑点被砍了[1][1]） f[u][1][1]=∑f[x][0][1]*（f[v][1][1]+f[v][0][0]），它为白以它为根的子树中有且只有一个黑点， 则只有一个黑点儿子不被砍，其余儿子中要么没有黑点[0][0]要么有黑点被砍了[1][1] 最后答案为f[0][0][1] */ #include<iostream> #include<cstdio> #include<cstring> #include<cstdlib> #define mod 1000000007 #define N 100005 using namespace std; long long f[N][2][2]; int tot,n; int head[N],col[N],son[N]; struct node { int to,next; }e[N<<2]; inline int read() { int x=0,f=1;char c=getchar(); while(c>'9'||c<'0'){if(c=='=')f=-1;c=getchar();} while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();} return x*f; } inline void add(int u,int v) { e[++tot].to=v;e[tot].next=head[u];head[u]=tot; } void dfs(int u,int v) { for(int i=head[u];~i;i=e[i].next) { if(e[i].to==v) continue; dfs(e[i].to,u); son[u]=1; } } void dp(int u,int v) { if(!son[u]) { if(col[u]) { f[u][1][1]=1;f[u][1][0]=0; f[u][0][1]=1;f[u][0][0]=0; } else { f[u][1][1]=0;f[u][1][0]=1; f[u][0][1]=0;f[u][0][0]=1; }return; } for(int i=head[u];~i;i=e[i].next) { if(e[i].to==v) continue; dp(e[i].to,u); } if(col[u]) { f[u][1][0]=0;f[u][0][0]=0; long long sum=1; for(int i=head[u];~i;i=e[i].next) { int t=e[i].to; if(t==v)continue; sum=sum*(f[t][0][0]+f[t][1][1])%mod; } f[u][0][1]+=sum;f[u][1][1]+=sum; } else { f[u][1][0]=0; long long sum=1; for(int i=head[u];~i;i=e[i].next) { int t=e[i].to; if(t==v)continue; sum=sum*(f[t][0][0]+f[t][1][1])%mod; } f[u][0][0]+=sum; long long ans=0;sum=1; for(int i=head[u];~i;i=e[i].next,sum=1) { if(e[i].to==v)continue; int tmp=f[e[i].to][0][1]; if(!tmp)continue; for(int j=head[u];~j;j=e[j].next) { int t=e[j].to; if(t==v || j==i) continue; sum=sum*(f[t][0][0]+f[t][1][1])%mod; } ans=(ans+tmp*sum)%mod; } f[u][1][1]=ans%mod;f[u][0][1]=ans%mod; } } int main() { // freopen("tree.in","r",stdin); // freopen("tree.out","w",stdout); /* 手动扩栈 int size = 256 << 16; // 256MB char *p = (char*)malloc(size) + size; __asm__("movl %0, %%esp\n" :: "r"(p)); */ memset(head,-1,sizeof head); n=read();int x; for(int i=0;i<n-1;i++) { x=read(); add(x,i+1);add(i+1,x); } for(int i=0;i<n;i++) col[i]=read(); dfs(0,-1);dp(0,-1); cout<<f[0][0][1]%mod; return 0; }
100+40+0 T2没想出来。 嗯没错，T3暴力挂了，水了30分链一分没得，这让大数据结构如此擅长水链分的我特别桑心了，，，，，， 唉，愁得我......T3还是没耐心写暴力吧(想到80分暴力貌似不对，写了也不一定调出来)，还是太弱了，myj大佬都开始挨个刷bzoj了.....不怂就是干！晚上吧全排列写5边！！！(被stl坑了一把)。 T3正解一晚上没懂，上午半上午才又找了一个看懂了，唉...... 我就不信这个邪......
