【NOIP2018 模拟】

A. 【NOIP2018 模拟】剑与魔法

【问题描述】

万老师听说某大国很流行穿越，于是他就想写一个关于穿越的剧本。

闲话休提。话说老师穿越到了某一个剑与魔法的大陆。因为如此这般，所以老师从维娜艾那里得到了预言。老师一共被告知了若干件按顺序结算的 事件。这些事件分为两类：战役事件（CASE）、穿越回去事件（END）。战役事件可以选择是否参加，参加了之后会获得一定的金钱。每个END事件 发生需要至少参加一定数量的战役事件。特别的是，END事件如果满足要求就会强制发生。老师希望在大陆玩个够，所以他要求只有最后一个END事 件会发生。老师希望获得最多的金钱，所以求助于你。

【输入】

第一行一个数N，表示输入文件有多少行。 接下来每一行用空格隔开一个字符和一个整数。字符为“c”表示战役事件，接下来的整数表示这次涨RP顺带有多少钱；字符为“e”表示穿越回去 事件，接下来的整数代表至少要涨多少RP。最后一个事件保证是END事件。

【输出】

第一行一个整数，最多金钱数目。

若不可能则输出-1。

【输入输出样例】

dragons.in

5

c 10

c 12

e 2

c 1

e 2

dragons.out

13

【数据说明】

30%的数据满足 N<=20

60%的数据满足 N<=1,000

100%的数据满足 N<=200,000

每次涨RP事件赏金不超过10,000

穿越事件的要求不超过200,000

 思路：贪心。

我们可以忽视最后一个 end ，然后一个一个输入数据，将 case 的值 w 存入堆中排序，以后每遇到一个 end 就将堆中元素（最小值）删直要求的最多元素-1，

循环过后再将堆中元素相加，若堆中元素个数满足最后一个 end 的个数条件，就输出元素之和，反之，输出 -1 .

code

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

priority_queue<int> q;
int n,x;

int read(){
    int x=0,f=1;
    char s=getchar();
    while(!isdigit(s)) f*=(s=='-')? -1:1,s=getchar();
    do x=(x<<1)+(x<<3)+(s^48),s=getchar();
    while(isdigit(s));
    return x*f;
}

int main(){
    n=read();
    for(int i=1;i<=n;i++){
        char s[5];
        scanf("%s",s);
        x=read();
        if(i==n) break;
        if(s[0]=='c'){
            q.push(-x);
        }
        else {
            while(q.size()>=x)
            q.pop();
        }
    }
    int ans=0,num=0;
    while(q.size()){
        ans-=q.top();
        q.pop();
        num++;
    }
    if(num>=x) printf("%d",ans);
    else printf("-1");
    return 0;
} 

B. 【NOIP2018 模拟】矩形

【问题描述】

因为对polo忍无可忍， dzf使用圣剑在地上划出了许多纵横交错的沟壑来泄愤。这些沟壑都严格与X轴平行或垂直。 polo嘲笑了dzf无聊的行为，然后做了一件更加无聊的事。他蹲下来数这些沟壑的条数。数着数着，polo意识到一个问题，那就是因为圣剑的威力太大，划出的沟壑太多，地面就会塌陷。而如果两条水平的沟壑和两条垂直的沟壑相交组成了一个矩形，那么塌陷的危险就会进一步增加。现在polo已经数了n条沟壑，他想知道这些沟壑组成了多少个矩形。

【输入】

第一行一个数n,接下来每行4个数x1,y1,x2,y2，表示沟壑的两个端点(x1,y1),(x2,y2)

【输出】

一个数，组成的矩形个数。

【输入输出样例1】

rect.in

4

0 0 1 0

0 0 0 1

1 1 1 -1

1 1 0 1

rect.out

1

【输入输出样例2】

rect.in

8

1 0 4 0

2 1 2 0

0 0 0 3

2 2 2 3

3 3 3 -1

0 3 4 3

4 1 -1 1

3 2 -1 2

rect.out

6

【数据说明】

对于30%的数据，1<=n<=100

对于60%的数据，1<=n<=600

对于100%的数据，1<=n<=2000,坐标绝对值小于10^9，任意两条与X轴水平的沟壑之间没有交点，任意两条与X轴垂直的沟壑没有交点。

思路：对任意的两条横着（或竖着）的边计算交点，然后通过求他的组合数累加（k*(k-1)/2)。枚举一条垂直的线段L1，同时

用线段树维护与L1在区间[l,r]内相交的水平线段个数。同时按y递增的顺序枚举
另一条垂直线段L2,要求L2的y值大于L1。

code

#include<bits/stdc++.h>
#define N 2001

using namespace std;

int f[5*N],ji[5*N],tree[5*N];
int n,x,n1,n2,len,tot;
long long ans;

struct Node
{
    int x1,y1,x2,y2;
}a[N],b[N],c[N];

bool cmp(Node a,Node b)
{
    return a.x1<b.x1; 
}

bool cmp1(Node a,Node b)
{
    return a.x2<b.x2;
}

int query(int t,int l,int r,int x,int y)
{
    if(x<=l && r<=y) 
    {
        return tree[t];
    }
    int mid=(l+r)/2;
    if(y<=mid) 
    {
        return query(2*t,l,mid,x,y);
    }
    else if(x>mid) 
    {
        return query(2*t+1,mid+1,r,x,y);
    }
    else 
    {
        return query(2*t,l,mid,x,mid)+query(2*t+1,mid+1,r,mid+1,y);
    }
}

void change(int t,int l,int r,int x,int y)
{
    if(l==r) 
    {
        tree[t]+=y; 
        return;
    }
    int mid=(l+r)/2;
    if(x<=mid) 
    {
        change(2*t,l,mid,x,y);  
    }
    else 
    {
        change(2*t+1,mid+1,r,x,y);
    }
    tree[t]=tree[2*t]+tree[2*t+1];
}

int search(int t,int l,int r)
{
    int mid=(l+r)/2;
    if(f[mid]==t) 
    {
        return ji[mid];
    }
    if(t>f[mid]) 
    {
        return search(t,mid+1,r); 
    }
    else 
    {
        search(t,l,mid-1);
    }
}

int find(int t,int l,int r)
{
    if(l>r)return l;
    int mid=(l+r)/2;
    if(t>c[mid].x2) 
    {
        return find(t,mid+1,r);
    }
    else 
    {
        return find(t,l,mid-1);
    }
}

long long clam(long long x)
{
    return x*(x-1)/2;
}

int main()
{
    //freopen("readin.txt","r",stdin);
    scanf("%d",&n);
    for(int i=1;i<=n;i++) 
    {
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        if(x1==x2)
        {
            a[++n1]={x1,y1,x2,y2};
            if(a[n1].y1>a[n1].y2)swap(a[n1].y1,a[n1].y2);
        }
        else
        {
            b[++n2]={x1,y1,x2,y2};
            if(b[n2].x1>b[n2].x2)swap(b[n2].x1,b[n2].x2);
        }
    }
    sort(a+1,a+n1+1,cmp);
    for(int i=1;i<=n1;i++) 
    {
        f[++tot]=a[i].y1;
        f[++tot]=a[i].y2;
    }
    for(int i=1;i<=n2;i++) 
    {
        f[++tot]=b[i].y1;
        f[++tot]=b[i].y2;
    }
    sort(f+1,f+tot+1);
    x=ji[1]=1;
    for(int i=2;i<=tot;i++) 
    {
        if(f[i]!=f[i-1])x++;
        ji[i]=x;
    }
    for(int i=1;i<=n1;i++)
    {
        a[i].y1=search(a[i].y1,1,tot);
        a[i].y2=search(a[i].y2,1,tot);
    }
    for(int i=1;i<=n2;i++) 
    {
        b[i].y1=search(b[i].y1,1,tot);
        b[i].y2=search(b[i].y2,1,tot);
    }
    for(int i=1;i<=n1;i++) 
    {
        len=0; 
        memset(tree,0,sizeof(tree));
        for(int j=1;j<=n2;j++) 
        if(a[i].y1<=b[j].y1 && b[j].y1<=a[i].y2 && b[j].x1<=a[i].x1 && a[i].x1<=b[j].x2)  
        {
            c[++len]={b[j].x1,b[j].y1,b[j].x2,b[j].y2};
            change(1,1,x,c[len].y1,1); 
        }
        sort(c+1,c+len+1,cmp1); 
        int last=1; 
        for(int j=i+1;j<=n1;j++) 
        if(a[j].x1>a[i].x1) 
        {
            int t=find(a[j].x1,last,len); 
            for(int k=last;k<t;k++)
            {
                change(1,1,x,c[k].y1,-1); 
            }
            last=t;
            long long s=0;
            int up=min(a[i].y2,a[j].y2),down=max(a[i].y1,a[j].y1);
            if(down<=up)
            {
                s=query(1,1,x,down,up); 
            }
            ans+=clam(s); 
        }
    }
    printf("%lld
",ans);
    return 0;
}

C. 【NOIP2018 模拟】数列的GCD

【问题描述】

给出一个长度为N的数列{a[n]}，1<=a[i]<=M(1<=i<=N)。

现在问题是，对于1到M的每个整数d，有多少个不同的数列b[1], b[2], ..., b[N]，满足：

(1)1<=b[i]<=M(1<=i<=N)；

(2)gcd(b[1], b[2], ..., b[N])=d；

(3)恰好有K个位置i使得a[i]<>bi

注：gcd(x1,x2,...,xn)为x1, x2, ..., xn的最大公约数。

输出答案对1,000,000,007取模的值。

【输入】

第一行包含3个整数，N，M，K。

第二行包含N个整数：a[1], a[2], ..., a[N]。

【输出】

输出M个整数到一行，第i个整数为当d=i时满足条件的不同数列{b[n]}的数目mod 1,000,000,007的值。

【输入输出样例1】

gcd.in

3 3 3

3 3 3

gcd.out

7 1 0

【输入输出样例2】

gcd.in

3 5 3

1 2 3

gcd.out

59 3 0 1 1

【样例1解释】

当d=1，{b[n]}可以为：(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2), (2, 1, 1), (2, 1, 2), (2, 2, 1)。

当d=2，{b[n]}可以为：(2, 2, 2)。

当d=3，因为{b[n]}必须要有k个数与{a[n]}不同，所以{b[n]}不能为(3, 3, 3)，满足条件的一个都没有。

【数据说明】

对于30%的数据，1<=N<=20, 1<=M<=2。

对于50%的数据，1<=N,M<=1000。

对于70%的数据，1<=N,M<=10000。

对于100%的数据，1<=N,M<=300000, 1<=K<=N, 1<=a[i]<=M。

 思路：有k个不相同的位置，那么也就是只有n-k个位置相同，考虑A中如果能有一些数使得它们的GCD为d，那么它们肯定是d的倍数。我们可以枚举d，用筛法算出d倍数的个数sum，相同的方案数为C(sum,n-k)，我们还要把sum-(n-k)个强制变为不同。即个数为(m/d-1)^sum-n+k,另外的n-sum个数方案为(m/d)^n-sum,再考虑容斥

code

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

const int N=300005;
const int M=1000000007;
int n,m,k,i,j,a[N],p[N];
ll fac[N],inv[N],f[N];

ll C(int n,int m)
{
    return fac[n]*inv[m]%M*inv[n-m]%M;
}

ll powmod(ll a,int b)
{
    ll ans=1;
    while(b)
    {
        if(b&1) ans=ans*a%M;
        a=a*a%M;
        b>>=1;
    }
    return ans;
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        p[a[i]]++;
    }
    inv[0]=inv[1]=1;
    for(i=2;i<=n;i++) inv[i]=inv[M%i]*(M-M/i)%M;
    for(i=2;i<=n;i++) inv[i]=inv[i]*inv[i-1]%M;
    fac[0]=1;
    for(i=1;i<=n;i++) fac[i]=fac[i-1]*i%M;
    for(i=m;i>=1;i--)
    {
        int sum=0;
        for(j=i;j<=m;j+=i) sum+=p[j];
        if(sum-n+k<0) f[i]=0;else
        f[i]=C(sum,n-k)*powmod(m/i-1,sum-n+k)%M*powmod(m/i,n-sum)%M;
        for(j=i<<1;j<=m;j+=i) f[i]=(f[i]-f[j]+M)%M;
    }
    for(i=1;i<=m;i++)
    {
        printf("%lld",f[i]);
        if(i<m) printf(" ");
    }
    return 0;
}

 （未完......)