cogs 比赛名称 树立信心的模拟赛

T1 2739. 凯伦和咖啡

时间限制：1 s   内存限制：512 MB

【题目描述】

为了在上课时保持清醒，凯伦需要一些咖啡。咖啡爱好者凯伦想知道最佳的温度来冲煮完美的咖啡。因此，她花了一些时间阅读几本食谱，其中包括广受好评的“咖啡的艺术”。

她知道有n个食谱，其中第i个食谱建议应当在li和ri度之间冲煮以达到最佳的味道。凯伦认为如果至少k个食谱推荐某个温度，那么那个温度是可以接受的。

凯伦的性格比较多变，因此她会问q个问题，对于每一个问题，她会给出一个温度区间[a,b]，你要告诉她有多少可接受的整数温度在这个范围内。

必须要放上图片...=n=

【输入格式】

第一行输入包含三个整数，n，k（1≤k≤n≤200000）和q（1≤q≤200000），如题中所描述。

接下来n行描述每一个食谱，具体来说，其中的第i行包含两个整数li和ri（1≤li≤ri≤200000），描述第i个食谱建议咖啡在li和ri度之间进行冲煮（包括端值）。

接下来q行为q个询问。这些行中的每一行都包含a和b，（1≤a≤b≤200000），表示她想知道a和b度之间的可接受的整数温度的数量，包括a和b。

【输出格式】

对于每个询问，一行输出一个答案。

【样例输入】

3 2 4

91 94

92 97

97 99

92 94

93 97

95 96

90 100

【样例输出】

3

3

0

4

【提示】

数据进行了更新，卡掉了部分暴力程序。

题目大意 ：

有n个线段覆盖，q个询问，问区间[a,b]之间有多少个点被大于等于k的线段覆盖着。

题解：

差分+树状数组维护前缀和。

暴力的想法是，每一个线段覆盖的区间都打标记，即 for(i=x--y)f[i]++;

最后在查询时看看区间里 有多少个点的标记是>=k的。时间复杂度O（n^2+nq）

慢的原因是每个点挨个打标记太浪费时间了，所以当[x,y]被线段覆盖时，只需打

两个标记a[x]++,a[y+1]--，这样处理a数组的前缀和，sum[i]就是i这个点被覆盖的

线段个数，我们将被覆盖的线段个数大于等于k放入树状数组求值就可以了。

1A，时间0.314s排名第三 耶=u=

代码

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

int n,k,q,x,y,qx,qy,maxn;
int a[200002],sum[200002],tree[200002];

int lowbit(int x){
    return x&(-x);
}

void add(int x){
    while(x<=maxn+10){
        tree[x]++;
        x+=lowbit(x);
    }
}

int query(int a,int b){
    int suma=0,sumb=0;a--;
    while(a){
        suma+=tree[a];
        a-=lowbit(a);
    }
    while(b){
        sumb+=tree[b];
        b-=lowbit(b);
    }
    return sumb-suma;
}

int main(){
    freopen("coffee.in","r",stdin);
    freopen("coffee.out","w",stdout);
    scanf("%d%d%d",&n,&k,&q);
    //n个食谱，至少k个，q次询问。
    for(int i=1;i<=n;i++){
        scanf("%d%d",&x,&y);
        a[x]++;a[y+1]--;
        maxn=max(maxn,max(x,y));
    }
    for(int i=1;i<=maxn;i++){
        sum[i]=sum[i-1]+a[i];
        if(sum[i]>=k)add(i);
    }
    for(int i=1;i<=q;i++){
        scanf("%d%d",&qx,&qy);
        printf("%d\n",query(qx,qy));
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}

T2 2739. 凯伦和咖啡

★★   输入文件：games.in   输出文件：games.out   简单对比
时间限制：2 s   内存限制：512 MB

【题目描述】

在她上学的路上，她沉迷于一款益智游戏无法自拔。

游戏是这样的：在每一关，你都有一个n行m列的网格。每个单元最初为数字0。每一步你可以选择一行或一列，并将该行或列中的所有单元格添加1。为了通关，你需要在所有的移动之后使第i行第j列的数字为g[i][j]。凯伦想知道一种使用最少步数通关的方法。

【输入格式】

第一行输入包含两个整数，分别为n和m（1≤n，m≤100），表示网格中的行数和列数。

接下来的n行每行都包含m个整数。第i行的第j个整数表示g[i][j]（0≤g[i][j]≤500）。

【输出格式】

如果无法通关，输出-1。

否则，第一行输出一个整数k表示最小步数

接下来k行包含以下两项，用来描述一步操作

row x,(1<=x<=n)表示选第x行。

col x,(1<=x<=m)表示选第x列。

如果有多个答案，输出字典序最小的一个。（就是先输出行，按行号从小到大，再输出列，按列号从小到大）

【样例输入1】

3 5

2 2 2 3 2

0 0 0 1 0

1 1 1 2 1

【样例输出1】

4

row 1

row 1

row 3

col 4

【样例输入2】

3 3

0 0 0

0 1 0

0 0 0

【样例输出2】

-1

【样例输入3】

3 3

1 1 1

1 1 1

1 1 1

【样例输出3】

3

row 1

row 2

row 3

【来源】

题目大意：要求一个都是0的矩阵，每一步可以把一行或者是一列都+1，求多少步可以变成目标矩阵。

题解：

80分贪心。啊啊我知道为什么错了...因为要最小步数 所以要判断行和列谁大，万一这个矩阵又高又瘦呢...

先消除行不就不划算了么....

每一列或者是行都加1太麻烦了，所以我们的问题转换成目标矩阵每一步能把一行或者是一列-1，求几步

能变成都是0的矩阵。

贪心的做法是，统计每一行和每一列的最小值。如果某一行或者是某一列的的最小值为0，那么就不能一次性

将这一行或一列都-1。因为要求字典序最小，我们先看行，每行减去它的非零最小值，非0最小值是这一行的

最小值不能为0，更新列的最小值，然后在减去每一列的非零最小值，判断是否矩阵的值都为0；

代码：

80贪心。AC代码

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

int n,m,k;
int minrow[520],mincol[520],a[520][520];
struct A {
    int id,s,js;//id表示行（1）还是列（0），s表示哪一个。
} ans[255000];

bool check() {
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            if(a[i][j])return false;
    return true;
}

int main() {
    freopen("games.in","r",stdin);
    freopen("games.out","w",stdout);
    scanf("%d%d",&n,&m);
    //n行 m列
    memset(minrow,127/3,sizeof(minrow));
    memset(mincol,127/3,sizeof(mincol));
    for(int i=1; i<=n; i++) {
        for(int j=1; j<=m; j++) {
            scanf("%d",&a[i][j]);
            minrow[i]=min(minrow[i],a[i][j]);//第i行最小的数
            mincol[j]=min(mincol[j],a[i][j]);//第j列最小的数
        }
    }
    if(m>=n) {
        for(int i=1; i<=n; i++) {
            if(minrow[i]==0)continue;
            for(int j=1; j<=m; j++) {
                a[i][j]-=minrow[i];
                mincol[j]=min(mincol[j],a[i][j]);
            }
            ans[++k].id=1;
            ans[k].s=i;
            ans[k].js=minrow[i];
            minrow[i]=0;
        }
        for(int i=1; i<=m; i++) {
            if(mincol[i]==0)continue;
            for(int j=1; j<=n; j++) {
                a[j][i]-=mincol[i];
            }
            ans[++k].id=0;
            ans[k].s=i;
            ans[k].js=mincol[i];
            mincol[i]=0;
        }
    } else {
        for(int i=1; i<=m; i++) {
            if(mincol[i]==0)continue;
            for(int j=1; j<=n; j++) {
                a[j][i]-=mincol[i];
                minrow[j]=min(minrow[j],a[j][i]);
            }
            ans[++k].id=0;
            ans[k].s=i;
            ans[k].js=mincol[i];
            mincol[i]=0;
        }
        for(int i=1; i<=n; i++) {
            if(minrow[i]==0)continue;
            for(int j=1; j<=m; j++) {
                a[i][j]-=minrow[i];
                mincol[j]=min(mincol[j],a[i][j]);
            }
            ans[++k].id=1;
            ans[k].s=i;
            ans[k].js=minrow[i];
            minrow[i]=0;
        }
    }
    if(check()) {
        int p=0;
        for(int i=1; i<=k; i++)p+=ans[i].js;
        printf("%d\n",p);
        for(int i=1; i<=k; i++) {
            if(ans[i].id==1) {
                for(int j=1; j<=ans[i].js; j++)
                    printf("row %d\n",ans[i].s);
            } else {
                for(int j=1; j<=ans[i].js; j++)
                    printf("col %d\n",ans[i].s);
            }
        }
    } else printf("-1");
    fclose(stdin);
    fclose(stdout);
    return 0;
}

T3 2747. 凯伦和超市

★★★   输入文件：market.in   输出文件：market.out   简单对比
时间限制：2 s   内存限制：512 MB

【题目描述】

在回家的路上，凯伦决定停在超市买些杂货。

她需要买很多商品，但由于她是学生，她的预算还是相当有限的。其实她只能花最高b美元。

超市里有n种商品，第i种商品价格为c[i]美元。当然，每种商品只能买一次。最近，超市一直在努力增加业务，作为忠实客户的凯伦，获得了n张优惠券，如果凯伦买了第i件商品，她可以用第i张优惠券来降低d[i]的价格。当然，如果不买相应的商品就无法使用优惠券。

然而，优惠券有一定限制：对于所有i≥2，为了使用第i张优惠券，凯伦也必须使用第xi张优惠券（这可能意味着使用更多的优惠券来满足该优惠券的要求）。凯伦想知道，用她的钱最多可以买多少商品。

【输入格式】

第一行输入包含两个整数n和b（1≤n≤5000,1≤b≤10^9），商店中的货物数量和凯伦的钱数。

接下来的n行描述以下项：

其中第i行开始是两个整数分别为次c[i]和d[i](1<=d[i]<c[i]<=10^9)，表示第i个商品的价钱和用第i张优惠券买这个商品可以减少的价钱，如果i>=2，接下来是另一个整数x[i](1<=x[i]<i)，表示第x[i]张优惠券应该先被使用。

【输出格式】

输出一行，一个整数，即凯伦能买到的最大的商品数。

【样例1】

input

6 16

10 9

10 5 1

12 2 1

20 18 3

10 2 3

2 1 5

output

4

【样例2】

input

5 10

3 1

3 1 1

3 1 2

3 1 3

3 1 4

output

5

【提示】

在此键入。

【来源】

在此键入。

题目大意：n个商品 b个钱，每个商品都有优惠券可以减少一定的价钱，但是除了第一个商品，使用优惠券必须要满足使用第xi优惠券。

每种物品只能买一次...

题解：tan 90

一开始以为是有依赖性背包问题...想想不是...

有觉得是拓扑+dp...推不出来。

还是dfs好了，0分懵比。ORZ

代码：

懵比0分dfs

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

int n,b,pre,ans,sumedge,head[5005],c[5005],d[5005];

struct Edge{
    int x,y,nxt;
    Edge(int x=0,int y=0,int nxt=0):
        x(x),y(y),nxt(nxt){}
}edge[5019];

void add(int x,int y){
    edge[++sumedge]=Edge(x,y,head[x]);
    head[x]=sumedge;
}

void dfs(int x,int use,int buy,int sum,int all){
    ans=max(ans,sum);
    if(all>b)return;
    if(x==0){
        dfs(x+1,1,1,sum+1,all+c[1]-d[1]);
        dfs(x+1,0,1,sum+1,all+c[1]);
        dfs(x+1,-1,0,sum,all);
    }
    if(use==1){
        for(int i=head[x];i;i=edge[i].nxt){
            int v=edge[i].y;
            dfs(v,1,1,sum+1,all+c[v]-d[v]);
            dfs(v,0,1,sum+1,all+c[v]);
            dfs(v,-1,0,sum,all);
        }
    }else
    if(use==0){
        for(int i=head[x];i;i=edge[i].nxt){
            int v=edge[i].y;
            dfs(v,-1,0,sum,all);
            dfs(v,0,1,sum+1,all+c[v]);
        }
    }else
    if(use==-1){
        for(int i=head[x];i;i=edge[i].nxt){
            int v=edge[i].y;
            dfs(v,-1,0,sum,all);
            dfs(v,0,1,sum+1,all+c[v]);
        }
    }
    return ;
}

int main(){
    freopen("market.in","r",stdin);
    freopen("market.out","w",stdout);
    scanf("%d%d",&n,&b);
    //货物的数量 凯伦的钱数。
    scanf("%d%d",&c[1],&d[1]);
    //第1个商品的价钱和第一个商品用优惠券减少的价钱。
    for(int i=2;i<=n;i++){
        scanf("%d%d%d",&c[i],&d[i],&pre);
        add(pre,i);
    }
    dfs(0,0,0,0,0);
    //买了几个物品，这个物品用没用优惠券
    //买没买 买个几个物品 花了多少钱。
    printf("%d\n",ans);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

正解是树形dp...因为我还没做过...所以我先做几道题再回来补这个坑.=u=