noip2016提高组day2

组合数问题

题目描述

组合数 CnmC_n^mCnm​ 表示的是从 nnn 个物品中选出 mmm 个物品的方案数。举个例子，从 (1,2,3)(1,2,3)(1,2,3) 三个物品中选择两个物品可以有 (1,2),(1,3),(2,3)(1,2),(1,3),(2,3)(1,2),(1,3),(2,3) 这三种选择方法。根据组合数的定义，我们可以给出计算组合数 CnmC_n^mCnm​ 的一般公式：

Cnm=n!m!(n−m)!C_n^m=frac{n!}{m!(n-m)!}Cnm​=m!(n−m)!

n!​

其中 n!=1×2×⋯×nn!=1 imes2 imescdots imes nn!=1×2×⋯×n；特别地，定义 0!=10!=10!=1。

小葱想知道如果给定 n,mn,mn,m 和 kkk，对于所有的 0≤i≤n,0≤j≤min⁡(i,m)0leq ileq n,0leq jleq min left ( i, m ight )0≤i≤n,0≤j≤min(i,m) 有多少对 (i,j)(i,j)(i,j) 满足 CijC_i^jCij​ 是 kkk 的倍数。

输入输出格式

输入格式：

第一行有两个整数 t,kt,kt,k，其中 ttt 代表该测试点总共有多少组测试数据，kkk 的意义见问题描述。

接下来 ttt 行每行两个整数 n,mn,mn,m，其中 n,mn,mn,m 的意义见问题描述。

输出格式：

共 ttt 行，每行一个整数代表所有的 0≤i≤n,0≤j≤min⁡(i,m)0leq ileq n,0leq jleq min left ( i, m ight )0≤i≤n,0≤j≤min(i,m) 中有多少对 (i,j)(i,j)(i,j) 满足 CijC_i^jCij​ 是 kkk 的倍数。

输入输出样例

输入样例#1： 复制

1 2
3 3

输出样例#1： 复制

1

输入样例#2： 复制

2 5
4 5
6 7

输出样例#2： 复制

0
7

说明

【样例1说明】

在所有可能的情况中，只有C21=2C_2^1 = 2C21​=2是2的倍数。

【子任务】

首先要明白一个公式：c(i,j)=c(i-1,j)+c(i-1,j-1),所以可以先把图打出来，注意每次都要取模，否则会炸；

如何计算个数？运用dp（或前缀和？）的思想ans[i][j]=ans[i-1][j]+ans[i][j-1]-ans[i-1][j-1]+cnt[i][j];ans[i][j]指以i，j结尾的矩阵中的解；

#include<cstdio>
#include<cstring>
using namespace std;

inline int read(){
    int x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0') {if(ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') {x=x*10+ch-'0';ch=getchar();}
    return f*x;
}

int ans[2005][2005],mp[2005][2005],t,k;

void prepare(){
    mp[0][0]=mp[1][0]=mp[1][1]=1;
    for(int i=2;i<=2000;i++){
        mp[i][0]=1;
        for(int j=1;j<=i;j++){
            mp[i][j]=(mp[i-1][j]+mp[i-1][j-1])%k;
            ans[i][j]=ans[i-1][j]+ans[i][j-1]-ans[i-1][j-1];
            if(mp[i][j]==0) ans[i][j]++;
        }
        ans[i][i+1]=ans[i][i];//想想为什么
    }
}

int main(){
    //freopen("in.txt","r",stdin);
    t=read(),k=read();
    memset(mp,0,sizeof(mp));
    prepare();
    while(t--){
        int n=read(),m=read();
        if(m>n) m=n;
        printf("%d
",ans[n][m]);
    }
    return 0;
}

蚯蚓

题目描述

本题中，我们将用符号 ⌊c⌋lfloor c floor⌊c⌋ 表示对 ccc 向下取整，例如：⌊3.0⌋=⌊3.1⌋=⌊3.9⌋=3lfloor 3.0 floor = lfloor 3.1 floor = lfloor 3.9 floor = 3⌊3.0⌋=⌊3.1⌋=⌊3.9⌋=3。

蛐蛐国最近蚯蚓成灾了！隔壁跳蚤国的跳蚤也拿蚯蚓们没办法，蛐蛐国王只好去请神刀手来帮他们消灭蚯蚓。

蛐蛐国里现在共有 nnn 只蚯蚓（nnn 为正整数）。每只蚯蚓拥有长度，我们设第 iii 只蚯蚓的长度为 aia_iai​ (i=1,2,…,ni=1,2,dots,ni=1,2,…,n)，并保证所有的长度都是非负整数（即：可能存在长度为 000 的蚯蚓）。

每一秒，神刀手会在所有的蚯蚓中，准确地找到最长的那一只（如有多个则任选一个）将其切成两半。神刀手切开蚯蚓的位置由常数 ppp（是满足 0<p<10 < p < 10<p<1 的有理数）决定，设这只蚯蚓长度为 xxx，神刀手会将其切成两只长度分别为 ⌊px⌋lfloor px floor⌊px⌋ 和 x−⌊px⌋x - lfloor px floorx−⌊px⌋ 的蚯蚓。特殊地，如果这两个数的其中一个等于 000，则这个长度为 000 的蚯蚓也会被保留。此外，除了刚刚产生的两只新蚯蚓，其余蚯蚓的长度都会增加 qqq（是一个非负整常数）。

蛐蛐国王知道这样不是长久之计，因为蚯蚓不仅会越来越多，还会越来越长。蛐蛐国王决定求助于一位有着洪荒之力的神秘人物，但是救兵还需要 mmm 秒才能到来……（mmm 为非负整数）

蛐蛐国王希望知道这 mmm 秒内的战况。具体来说，他希望知道：

• mmm 秒内，每一秒被切断的蚯蚓被切断前的长度（有 mmm 个数）；
• mmm 秒后，所有蚯蚓的长度（有 n+mn + mn+m 个数）。

蛐蛐国王当然知道怎么做啦！但是他想考考你……

输入输出格式

输入格式：

第一行包含六个整数 n,m,q,u,v,tn,m,q,u,v,tn,m,q,u,v,t，其中：n,m,qn,m,qn,m,q 的意义见【问题描述】；u,v,tu,v,tu,v,t 均为正整数；你需要自己计算 p=u/vp=u / vp=u/v（保证 0<u<v0 < u < v0<u<v）；ttt 是输出参数，其含义将会在【输出格式】中解释。

第二行包含 nnn 个非负整数，为 a1,a2,…,ana_1, a_2, dots, a_na1​,a2​,…,an​，即初始时 nnn 只蚯蚓的长度。

同一行中相邻的两个数之间，恰好用一个空格隔开。

保证 1≤n≤1051 leq n leq 10^51≤n≤105，0≤m≤7×1060 leq m leq 7 imes 10^60≤m≤7×106，0<u<v≤1090 < u < v leq 10^90<u<v≤109，0≤q≤2000 leq q leq 2000≤q≤200，1≤t≤711 leq t leq 711≤t≤71，0≤ai≤1080 leq a_i leq 10^80≤ai​≤108。

输出格式：

第一行输出 ⌊mt⌋left lfloor frac{m}{t} ight floor⌊t

m​⌋ 个整数，按时间顺序，依次输出第 ttt 秒，第 2t2t2t 秒，第 3t3t3t 秒，……被切断蚯蚓（在被切断前）的长度。

第二行输出 ⌊n+mt⌋left lfloor frac{n+m}{t} ight floor⌊t

n+m​⌋ 个整数，输出 mmm 秒后蚯蚓的长度；需要按从大到小的顺序，依次输出排名第 ttt，第 2t2t2t，第 3t3t3t，……的长度。

同一行中相邻的两个数之间，恰好用一个空格隔开。即使某一行没有任何数需要输出，你也应输出一个空行。

请阅读样例来更好地理解这个格式。

输入输出样例

输入样例#1： 复制

3 7 1 1 3 1
3 3 2

输出样例#1： 复制

3 4 4 4 5 5 6
6 6 6 5 5 4 4 3 2 2

输入样例#2： 复制

3 7 1 1 3 2
3 3 2

输出样例#2： 复制

4 4 5
6 5 4 3 2

输入样例#3： 复制

3 7 1 1 3 9
3 3 2

输出样例#3： 复制

//空行
2

说明

【样例解释1】

在神刀手到来前：333只蚯蚓的长度为3,3,23,3,23,3,2。

111秒后：一只长度为333的蚯蚓被切成了两只长度分别为111和222的蚯蚓，其余蚯蚓的长度增加了111。最终444只蚯蚓的长度分别为(1,2),4,3(1,2),4,3(1,2),4,3。括号表示这个位置刚刚有一只蚯蚓被切断

222秒后：一只长度为444的蚯蚓被切成了111和333。555只蚯蚓的长度分别为：2,3,(1,3),42,3,(1,3),42,3,(1,3),4。

3秒后：一只长度为444的蚯蚓被切断。666只蚯蚓的长度分别为：3,4,2,4,(1,3)3,4,2,4,(1,3)3,4,2,4,(1,3)。

444秒后：一只长度为444的蚯蚓被切断。777只蚯蚓的长度分别为：4,(1,3),3,5,2,44,(1,3),3,5,2,44,(1,3),3,5,2,4。

555秒后：一只长度为555的蚯蚓被切断。888只蚯蚓的长度分别为：5,2,4,4,(1,4),3,55,2,4,4,(1,4),3,55,2,4,4,(1,4),3,5。

666秒后：一只长度为555的蚯蚓被切断。999只蚯蚓的长度分别为：(1,4),3,5,5,2,5,4,6(1,4),3,5,5,2,5,4,6(1,4),3,5,5,2,5,4,6。

777秒后：一只长度为666的蚯蚓被切断。101010只蚯蚓的长度分别为：2,5,4,6,6,3,6,5,(2,4)2,5,4,6,6,3,6,5,(2,4)2,5,4,6,6,3,6,5,(2,4)。所以，777秒内被切断的蚯蚓的长度依次为3,4,4,4,5,5,63,4,4,4,5,5,63,4,4,4,5,5,6。777秒后，所有蚯蚓长度从大到小排序为6,6,6,5,5,4,4,3,2,26,6,6,5,5,4,4,3,2,26,6,6,5,5,4,4,3,2,2

【样例解释2】

这个数据中只有t=2t=2t=2与上个数据不同。只需在每行都改为每两个数输出一个数即可。

虽然第一行最后有一个666没有被输出，但是第二行仍然要重新从第二个数再开始输出。

【样例解释3】

这个数据中只有t=9t=9t=9与上个数据不同。

注意第一行没有数要输出，但也要输出一个空行。

【数据范围】

刚开始用的合并果子的思想，直接开一个优先队列，但数据过大，会tel

仔细分析，发现其实这之间本生就有单调性，即长的蚯蚓被切后比短的切后要长，则在开两个对列，一个存被切后短的一段，另一个反之；

注意只能用手工队列，stl会超时

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1e5+10;
const int maxm=8e6;

inline int read(){
    int x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0') {if(ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') {x=x*10+ch-'0';ch=getchar();}
    return f*x;
}

int n,m,q,u,v,t,star[maxn],delta=0;

int qxz(int x)
{
    if(x<0) return x*((double)u/v)-1;
    else if(x==0) return 0;
    else return x*((double)u/v);
}

int qu1[maxm],qu2[maxm],qu3[maxm];

int h1,h2,h3,t1,t2,t3;

bool cmp(int a,int b){
    return a>b;
}

int ans[maxm];

int main(){
    ///freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    n=read(),m=read(),q=read(),u=read(),v=read(),t=read();
    h1=h2=h3=1;t1=t2=t3=0;
    for(int i=1;i<=n;i++) qu1[++t1]=read();
    sort(qu1+1,qu1+1+n,cmp);
    for(int i=1;i<=m;i++){
        int tp1=-1000000000,tp2=-1000000000,tp3=-1000000000,tp;
        if(h1<=t1) tp1=max(tp1,qu1[h1]);
        if(h2<=t2) tp2=max(tp2,qu2[h2]);
        if(h3<=t3) tp3=max(tp3,qu3[h3]);
        if(tp1>=tp2&&tp1>=tp3) tp=qu1[h1],h1++;
        else if(tp2>=tp1&&tp2>=tp3) tp=qu2[h2],h2++;
        else if(tp3>=tp1&&tp3>=tp2) tp=qu3[h3],h3++;
        tp+=delta;
        if(i%t==0) printf("%d ",tp);
        int a=qxz(tp),b=tp-a;
        delta+=q;
        a-=delta;b-=delta;
        if(a>=b) qu2[++t2]=a,qu3[++t3]=b;
        else qu2[++t2]=b,qu3[++t3]=a;
    }
    printf("
");
    int tot=0;
    while(h1<=t1||h2<=t2||h3<=t3){
        int tp1=-1000000000,tp2=-1000000000,tp3=-1000000000;
        if(h1<=t1) tp1=max(tp1,qu1[h1]);
        if(h2<=t2) tp2=max(tp2,qu2[h2]);
        if(h3<=t3) tp3=max(tp3,qu3[h3]);
        if(tp1>=tp2&&tp1>=tp3) ans[++tot]=qu1[h1],h1++;
        else if(tp2>=tp1&&tp2>=tp3) ans[++tot]=qu2[h2],h2++;
        else if(tp3>=tp1&&tp3>=tp2) ans[++tot]=qu3[h3],h3++;    
    }
    
    for(int i=1;i<=tot;i++){
        if(i%t==0) printf("%d ",ans[i]+delta);
    }
    return 0;
}

愤怒的小鸟

题目描述

Kiana 最近沉迷于一款神奇的游戏无法自拔。

简单来说，这款游戏是在一个平面上进行的。

有一架弹弓位于 (0,0)(0,0)(0,0) 处，每次 Kiana 可以用它向第一象限发射一只红色的小鸟，小鸟们的飞行轨迹均为形如 y=ax2+bxy=ax^2+bxy=ax2+bx 的曲线，其中 a,ba,ba,b 是Kiana 指定的参数，且必须满足 a<0a < 0a<0，a,ba,ba,b 都是实数。

当小鸟落回地面（即 xxx 轴）时，它就会瞬间消失。

在游戏的某个关卡里，平面的第一象限中有 nnn 只绿色的小猪，其中第 iii 只小猪所在的坐标为 (xi,yi)left(x_i,y_i ight)(xi​,yi​)。

如果某只小鸟的飞行轨迹经过了 (xi,yi)left( x_i, y_i ight)(xi​,yi​)，那么第 iii 只小猪就会被消灭掉，同时小鸟将会沿着原先的轨迹继续飞行；

如果一只小鸟的飞行轨迹没有经过 (xi,yi)left( x_i, y_i ight)(xi​,yi​)，那么这只小鸟飞行的全过程就不会对第 iii 只小猪产生任何影响。

例如，若两只小猪分别位于 (1,3)(1,3)(1,3) 和 (3,3)(3,3)(3,3)，Kiana 可以选择发射一只飞行轨迹为 y=−x2+4xy=-x^2+4xy=−x2+4x 的小鸟，这样两只小猪就会被这只小鸟一起消灭。

而这个游戏的目的，就是通过发射小鸟消灭所有的小猪。

这款神奇游戏的每个关卡对 Kiana来说都很难，所以Kiana还输入了一些神秘的指令，使得自己能更轻松地完成这个游戏。这些指令将在【输入格式】中详述。

假设这款游戏一共有 TTT 个关卡，现在 Kiana想知道，对于每一个关卡，至少需要发射多少只小鸟才能消灭所有的小猪。由于她不会算，所以希望由你告诉她。

输入输出格式

输入格式：

第一行包含一个正整数 TTT，表示游戏的关卡总数。

下面依次输入这 TTT 个关卡的信息。每个关卡第一行包含两个非负整数 n,mn,mn,m，分别表示该关卡中的小猪数量和 Kiana 输入的神秘指令类型。接下来的 nnn 行中，第 iii 行包含两个正实数 xi,yix_i,y_ixi​,yi​，表示第 iii 只小猪坐标为 (xi,yi)(x_i,y_i)(xi​,yi​)。数据保证同一个关卡中不存在两只坐标完全相同的小猪。

如果 m=0m=0m=0，表示Kiana输入了一个没有任何作用的指令。

如果 m=1m=1m=1，则这个关卡将会满足：至多用 ⌈n/3+1⌉lceil n/3 + 1 ceil⌈n/3+1⌉ 只小鸟即可消灭所有小猪。

如果 m=2m=2m=2，则这个关卡将会满足：一定存在一种最优解，其中有一只小鸟消灭了至少 ⌊n/3⌋lfloor n/3 floor⌊n/3⌋ 只小猪。

保证 1≤n≤181leq n leq 181≤n≤18，0≤m≤20leq m leq 20≤m≤2，0<xi,yi<100 < x_i,y_i < 100<xi​,yi​<10，输入中的实数均保留到小数点后两位。

上文中，符号 ⌈c⌉lceil c ceil⌈c⌉ 和 ⌊c⌋lfloor c floor⌊c⌋ 分别表示对 ccc 向上取整和向下取整，例如：⌈2.1⌉=⌈2.9⌉=⌈3.0⌉=⌊3.0⌋=⌊3.1⌋=⌊3.9⌋=3lceil 2.1 ceil = lceil 2.9 ceil = lceil 3.0 ceil = lfloor 3.0 floor = lfloor 3.1 floor = lfloor 3.9 floor = 3⌈2.1⌉=⌈2.9⌉=⌈3.0⌉=⌊3.0⌋=⌊3.1⌋=⌊3.9⌋=3。

输出格式：

对每个关卡依次输出一行答案。

输出的每一行包含一个正整数，表示相应的关卡中，消灭所有小猪最少需要的小鸟数量。

输入输出样例

输入样例#1： 复制

2
2 0
1.00 3.00
3.00 3.00
5 2
1.00 5.00
2.00 8.00
3.00 9.00
4.00 8.00
5.00 5.00

输出样例#1： 复制

1
1

输入样例#2： 复制

3
2 0
1.41 2.00
1.73 3.00
3 0
1.11 1.41
2.34 1.79
2.98 1.49
5 0
2.72 2.72
2.72 3.14
3.14 2.72
3.14 3.14
5.00 5.00

输出样例#2： 复制

2
2
3

输入样例#3： 复制

1
10 0
7.16 6.28
2.02 0.38
8.33 7.78
7.68 2.09
7.46 7.86
5.77 7.44
8.24 6.72
4.42 5.11
5.42 7.79
8.15 4.99

输出样例#3： 复制

6

说明

【样例解释1】

这组数据中一共有两个关卡。

第一个关卡与【问题描述】中的情形相同，222只小猪分别位于(1.00,3.00)(1.00,3.00)(1.00,3.00)和 (3.00,3.00)(3.00,3.00)(3.00,3.00)，只需发射一只飞行轨迹为y=−x2+4xy = -x^2 + 4xy=−x2+4x的小鸟即可消灭它们。

第二个关卡中有555只小猪，但经过观察我们可以发现它们的坐标都在抛物线 y=−x2+6xy = -x^2 + 6xy=−x2+6x上，故Kiana只需要发射一只小鸟即可消灭所有小猪。

【数据范围】

题目叙述很长，但仔细分析，发现数据都很小

考虑两种方法

1：dfs

dfs中存3中状态，到那个猪，用了几条抛物线，之前有几只单独的

#include<cstdio>
#include<cmath>
using namespace std;

const double eps=1e-8;
const int maxn=20;
int T,n,m,ans;

bool bj[maxn];

double x[maxn],y[maxn],wxa[maxn],wxb[maxn],tx[maxn],ty[maxn];

bool pd(double a,double b){
    return (fabs(a-b)<=eps);
}

void dfs(int dq,int u,int v){
    if(u+v>=ans) return;//最优性剪枝
    if(dq==n+1){
        ans=u+v;return;
    }
    bool flag=false;
    for(int i=1;i<=u;i++){//找原来的抛物线
        if(pd(wxa[i]*x[dq]*x[dq]+wxb[i]*x[dq],y[dq])) {
            flag=1;
            dfs(dq+1,u,v);
            break;
        }
    }
    if(!flag){
        for(int i=1;i<=v;i++){
            if(pd(x[dq],tx[i])) continue;
            double a=(y[dq]*tx[i]-ty[i]*x[dq])/(x[dq]*tx[i]*(x[dq]-tx[i]));
            double b=(ty[i]-a*tx[i]*tx[i])/tx[i];
            if(a<0) {
                bj[i]=1;
                wxa[u+1]=a,wxb[u+1]=b;
                double q=tx[i],w=ty[i];
                for(int j=i;j<v;j++) tx[j]=tx[j+1],ty[j]=ty[j+1];
                dfs(dq+1,u+1,v-1);
                for(int j=v;j>i;j--) tx[j]=tx[j-1],ty[j]=ty[j-1];
                tx[i]=q,ty[i]=w;//回溯操作
            } 
        }//与原来单独的猪结队
        tx[v+1]=x[dq],ty[v+1]=y[dq];
        dfs(dq+1,u,v+1);//独立出来，看能否与后面的猪结队或直接单独一个
    }
}

int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++) scanf("%lf%lf",x+i,y+i);
        ans=100;
        dfs(1,0,0);
        printf("%d
",ans);
    }
    return 0;
}

2：状态压缩，重点在处理抛物线

一次枚举每个节点，看能否组合成抛物线，再看后面的能否包含其中

转移方程直接看代码就好

#include<bits/stdc++.h>
using namespace std;
const double eps=1e-6;
int countpara,para[400],dp[1<<19],t,n,m;

double x[19],y[19];

int main(){
    scanf("%d",&t);
    while(t--){
        memset(dp,0x3f,sizeof(dp));
        dp[0]=0;
        countpara=0;
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++) scanf("%lf%lf",x+i,y+i);
        for(int i=0;i<n;i++){
            para[++countpara]=1<<i;
            for(int j=i+1,vis=0;j<n;j++){//vis用来判断节点是否已被包含进入抛物线里
                if(vis&(1<<j)) continue;
                if(x[i]==x[j]) continue;//注意，这个判断很重要，没加洛谷上只有90
                double a=(y[j]*x[i]-y[i]*x[j])/(x[i]*x[j]*(x[j]-x[i])),b=(y[j]-a*x[j]*x[j])/x[j];
                if(a>-eps) continue;
                para[++countpara]=(1<<i)|(1<<j);
                for(int k=j+1;k<n;k++){
                    if(fabs(a*x[k]*x[k]+b*x[k]-y[k])<=eps) 
                    vis|=(1<<k),para[countpara]|=(1<<k);
                }
            }
        }
        for(int i=0;i<(1<<n);i++){
            for(int j=1;j<=countpara;j++){
                dp[i|para[j]]=min(dp[i|para[j]],dp[i]+1);
            }
        }
        printf("%d
",dp[(1<<n)-1]);
    }
    return 0;
}