10.25日模拟试题

最新推荐文章于 2019-10-27 21:57:18 发布
最新推荐文章于 2019-10-27 21:57:18 发布
阅读量137 收藏
点赞数
原文链接：http://www.cnblogs.com/z360/p/7729005.html
版权

　　　　　　　　　　　　　　　　　　　　　10.25模拟赛

　　　　　　　　　　　　

 

　　　　　　　　　　　　　　　1 任务安排
manage.in/.out/.cpp
1.1 问题描述
你有 N 个工作，同一时刻只能做一个任务, 其中每个工作有其所需时
间, 及完成的 Deadline(截止时间), 问要完成所有工作, 最迟要从什么时候开
始。
你最早可以从时间 0 开始工作。
1.2 输入格式
第一行一个整数 N，表示任务数量
接下来 n 行，每行两个整数，T i ,S i ，分别表示该任务的持续时间和截
止时间。
1.3 输出格式
输出一个整数，表示最晚的开始时间，如果不能完成，输出-1。
1.4 样例输入
4
3 5
8 14
5 20
1 16
1.5 样例输出

3
1.6 数据规模及约定
对于 40% 的数据，N <= 20
对于 60% 的数据，N <= 1000
对于 100% 的数据，1<= N <= 100000
1<= T i <= 100000
1<= S i <= 1000000

 

贪心

我们按每一个任务的结束时间排序，这样我们可以最后在处理这个任务，然后我们计算每个任务开始的时间，如果一个任务开始的时间<=她的下一个任务结束的时间，那么我们把这个任务结束的时间设为上一个任务结束的时间，因为任务可以提前完成，如果一个任务开始的时间>下一个任务结束的时间，那么我们把这个任务结束的时间即为这个任务结束的时间，因为我们不可以晚结束、、

T为我们剩下的时间，如果T<0的话，任务不能全部完成，否则输出T

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 100010
using namespace std;
int read()
{
    int x=0,f=1; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*f;
}
struct Node
{
    int t,end;
}node[N];
int cmp(Node a,Node b){return a.end>b.end;}
int main()
{
    freopen("manage.in","r",stdin);
    freopen("manage.out","w",stdout);
    int n=read(); bool flag=false;
    for(int i=1;i<=n;i++)
     node[i].t=read(),node[i].end=read();
    sort(node+1,node+1+n,cmp);
    int T=node[1].end;
    for(int i=1;i<=n;i++)
    {
        if(T<=node[i].end) T-=node[i].t;
        else T=node[i].end,T-=node[i].t;
        if(T<0) {flag=true;break;}
    }
    if(flag) printf("-1");
    else printf("%d",T);
    return 0;
}
AC代码

 


　　　　　　　　　　　　2 小 a 的强迫症
qiang.in/.out/.cpp
2.1 问题描述
小 a 是一名强迫症患者，现在他要给一群带颜色的珠子排成一列，现在
有 N 种颜色，其中第 i 种颜色的柱子有 num(i) 个。要求排列中第 i 种颜色
珠子的最后一个珠子，一定要排在第 i+1 种颜色的最后一个珠子之前。问
有多少种排列珠子的方案。
2.2 输入格式
第一行一个整数 N，表示珠子颜色数量
第二行 N 个整数，分别表示每种珠子的颜色数量
2.3 输出格式

排列方案数，对 998244353 取余

2.4 样例输入

3
2 2 1
2.5 样例输出
3
2.6 数据规模及约定
共 3 种排列方案：
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
对于 40% 的数据，所有珠子数量和小于 15
对于 80% 的数据，N <= 1000，所有珠子数量和小于 5000
对于 100% 的数据，N <= 100000，所有珠子数量和小于 500000

 

组合数学+卢卡斯定理（组合数取模）

我们用一个sum数组记录一下珠子数量的前缀和，用s记录一下当前颜色的珠子的数量。对于一种珠子的最后一个排在他的后一个珠子的最后一个珠子之前，也就是说后面的珠子的最后一个一定是从他前的所有珠子的最后一个（现在它的位置是固定的了）那么还剩下s[i]-1个珠子，我们要把它放在sum[i]-1个珠子里的组合数为C(sum[i]-1,s[i]-1)   -1减去的是最后一个珠子，然后我们在用一下乘法原理。我们还可以看到sum<=500000，也就是说我们的组合数要取模，那么我们就要用卢卡斯定理了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 100010
#define mod 998244353
using namespace std;
long long n,ans,s[N],sum[N],f[N]={1,1},a[N]={1,1},g[N]={1,1};
long long read()
{
    long long x=0,f=1; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*f;
}
void work1()
{
    for(int i=2;i<=sum[n];i++) f[i]=f[i-1]*i;
    for(int i=2;i<=n;i++)
     ans=(ans%mod*(f[sum[i]-1]/f[s[i]-1]/(f[sum[i]-s[i]]))%mod)%mod;
    printf("%I64d",ans%mod);
}
int C(int n,int m)
{
    return (f[n]%mod*g[m]%mod*g[n-m]%mod)%mod;
}
void work2()
{
    for(int i=2;i<=sum[n];i++)
    {
        f[i]=(f[i-1]%mod*i%mod)%mod;
        a[i]=(mod-mod/i)*a[mod%i]%mod;
        g[i]=g[i-1]*a[i]%mod;
    }
    for(int i=2;i<=n;i++)
     ans=(ans%mod*C(sum[i]-1,s[i]-1)%mod)%mod;
    printf("%I64d",ans%mod);
}
int main()
{
    freopen("qiang.in","r",stdin);
    freopen("qiang.out","w",stdout);
    n=read();ans=1;
    for(int i=1;i<=n;i++) s[i]=read(),sum[i]=sum[i-1]+s[i];
    if(sum[n]<=15) work1();
    else work2();
    return 0;
}
80分代码

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 500010
#define mod 998244353
#define LL long long 
using namespace std;
long long n,ans,s[N],sum[N],f[N];
long long read()
{
    long long x=0,f=1; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*f;
}
int ins(int p)
{
    f[0]=1;
    for(int i=1;i<=p;i++)
     f[i]=(f[i-1]%mod*i%mod)%mod;
}
LL MI(LL a,LL b,int p)
{
    LL res=1;
    while(b)
    {
        if(b&1) res=(res%p*a%p)%p;
        b>>=1;a=(a%p*a%p)%p;
    }
    return res%mod;
}
LL C(LL n,LL m,int p)
{
    if(m>n) return 0;
    return f[n]%p*MI(f[m]%p*f[n-m]%p,p-2,p)%p;
}
LL lus(LL n,LL m,int p)
{
    if(m==0) return 1;
    return (C(n%p,m%p,p)%p*lus(n/p,m/p,p)%p)%p;
}
int main()
{
    freopen("qiang.in","r",stdin);
    freopen("qiang.out","w",stdout);
    n=read();ans=1;
    for(int i=1;i<=n;i++) s[i]=read(),sum[i]=sum[i-1]+s[i];
    ins(sum[n]);
    for(int i=2;i<=n;i++)
     ans=(ans%mod*1LL*lus(sum[i]-1,s[i]-1,mod)%mod)%mod;
    printf("%I64d",ans%mod);
    return 0;
}
AC代码

 

 


　　　　　　　　　　　　　　3 函数求和
sum.in/.out/.cpp
3.1 问题描述
你有一个含 N 个数字的数组 A，元素标号 1 到 N，同时他也有 N 个函
数，也标号 1 到 N。
第 i 个函数会返回数组中标号 L i 和 R i 之间的元素的和。
现在有以下两种询问：
1 x y 将数组的第 x 个元素修改为 y。
2 m n 询问标号在 m 和 n 之间的函数的值的和。
3.2 输入格式
输入数据第一行包含一个整数 N，表示数组的长度和函数的数量。
接下来的一行包含 N 个整数，表示数组中的元素 A i 。
接下来的 N 行，每行包含两个整数 L i ,R i ，表示一个函数。
接下来一行包含一个整数 Q，表示询问次数。
下面 Q 行，每行一个询问，格式见题目描述。
3.3 输出格式
对于每个第 2 类询问，输出相应的答案。
3.4 样例输入
5
1 2 3 4 5
1 3
2 5
4 5
3 5
1 2
4
2 1 4
1 3 7
2 1 4
2 3 5
4
3.5 样例输出
41
53
28
3.6 数据规模及约定
对于前 20% 的数据: N ≤ 1000,Q ≤ 1000
对于另外 30% 的数据: R i − L i ≤ 10, 所有的 x 各不相同
对于 100% 的数据: 1 ≤ N ≤ 10 5 , 1 ≤ L i ≤ R i ≤ N, 1 ≤ x ≤ N,
1 ≤ m ≤ n ≤ N, 1 ≤ A i ,y ≤ 10 9 , 1 ≤ Q ≤ 10

 

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 100010
#define LL long long
using namespace std;
int read()
{
    int x=0,f=1; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*f;
}
struct Tree
{
    int l,r,v;
}tree[N*4],node[N];
int n,Q,a,b,x,y,p;
long long ans;
void build(int k,int l,int r)
{
    tree[k].l=l,tree[k].r=r;
    if(tree[k].l==tree[k].r)
    {
        tree[k].v=read();
        return ;
    }
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    tree[k].v=tree[k<<1].v+tree[k<<1|1].v;
}
void change(int k)
{
    if(tree[k].l==tree[k].r)
    {
        tree[k].v=y;
        return ;
    }
    int mid=(tree[k].l+tree[k].r)>>1;
    if(x<=mid) change(k<<1);
    else change(k<<1|1);
    tree[k].v=tree[k<<1].v+tree[k<<1|1].v;
}
void ask(int k)
{
    if(tree[k].l>=a&&tree[k].r<=b)
    {
        ans+=(LL)tree[k].v;
        return;
    }
    int mid=(tree[k].l+tree[k].r)>>1;
    if(a<=mid) ask(k<<1);
    if(b>mid) ask(k<<1|1);
}
int main()
{
    freopen("sum.in","r",stdin);
    freopen("sum.out","w",stdout);
    n=read();build(1,1,n);
    for(int i=1;i<=n;i++) 
     node[i].l=read(),node[i].r=read();
    Q=read();
    while(Q--)
    {

        p=read(),x=read(),y=read(),ans=0;
        if(p==1) change(1); 
        else
        {
            for(int i=x;i<=y;i++)
              a=node[i].l,b=node[i].r,ask(1);
            printf("%I64d\n",ans);
        }
    }
    return 0;
}
0分线段树 
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef unsigned long long LL;
#define lowbit(x) ((x)&-(x))
int n;
int a[100005];
LL c[100005];
int L[100005],R[100005];
int Q;
int t[405][100005];
int belong[100005];// (i-1)/B+1
LL sum[405];
int B,NUM;
void add(int x,LL d){
    while(x<=n){
        c[x]+=d;
        x+=lowbit(x);
    }
}
LL ask(int x){
    LL ret=0;
    while(x){
        ret+=c[x];
        x-=lowbit(x);
    }
    return ret;
}
int main(){
    freopen("sum.in","r",stdin);
    freopen("sum.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    for(int i=1;i<=n;i++){
        scanf("%d%d",&L[i],&R[i]);
    }
    B=sqrt(n)+1;
//  printf("#%d\n",B);
    NUM=(n-1)/B+1;
    for(int i=1;i<=n;i++) belong[i]=(i-1)/B+1;
    for(int i=1;i<=n;i++) c[i]=a[i];
    for(int i=1;i<=n;i++){
        if(i+lowbit(i)<=n){
            c[i+lowbit(i)]+=c[i];
        }
    }
    for(int i=1;i<=n;i++){
        t[belong[i]][L[i]]++;
        t[belong[i]][R[i]+1]--;
    }
    for(int i=1;i<=NUM;i++){
        for(int j=1;j<=n;j++){
            t[i][j]+=t[i][j-1];
            sum[i]+=t[i][j]*1ULL*a[j];
        }
    }
    scanf("%d",&Q);
    while(Q--){
        int type,x,y;
        scanf("%d%d%d",&type,&x,&y);
        if(type==1){
            for(int i=1;i<=NUM;i++){
                sum[i]-=t[i][x]*1ULL*a[x];
                sum[i]+=t[i][x]*1ULL*y;
            }
            add(x,-a[x]);
            a[x]=y;
            add(x,a[x]);
        }else{
            int Ln,Rn;
            Ln=belong[x],Rn=belong[y];
            LL ans=0;
            if(Ln==Rn){
                for(int i=x;i<=y;i++){
                    ans+=ask(R[i])-ask(L[i]-1);
                }
            }else{
                for(int i=Ln+1;i<Rn;i++) ans+=sum[i];
                int lim;
                lim=Ln*B;
                lim=min(lim,y);
                for(int i=x;i<=lim;i++){
                    ans+=ask(R[i])-ask(L[i]-1);
                }
                lim=(Rn-1)*B+1;
                lim=max(lim,x);
                for(int i=lim;i<=y;i++){
                    ans+=ask(R[i])-ask(L[i]-1);
                }
            }
            printf("%I64d\n",ans);
        }
    }
    fclose(stdout);
    return 0;
}
果断粘std、、、

 

 

　　　　　　　　　　　　　　　　

 

 

　　　　　　　　　　　　　　　　　　　　　　距 NOIp2017 还剩 16 天

 

 　　                             你可以做的事情还有很多，即使到最后一秒也不要放弃，因为不到结束的那一刻谁也不知道结果会怎样

转载于:https://www.cnblogs.com/z360/p/7729005.html

weixin_33743703
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【12年特长生模拟第三题】【DP】尼克的任务
CW.
08-19 197
尼克的任务尼克的任务尼克的任务 题目 尼克每天上班之前都连接上英特网，接收他的上司发来的邮件，这些邮件包含了尼克主管的部门当天要完成的全部任务，每个任务由一个开始时刻与一个持续时间构成 尼克的一个工作日为NNN分钟，从第一分钟开始到第NNN分钟结束。当尼克到达单位后他就开始干活。如果在同一时刻有多个任务需要完戍，尼克可以任选其中的一个来做，而其余的则由他的同事完成，反之如果只有一个任务，则该任务必需由尼克去完成，假如某些任务开始时刻尼克正在工作，则这些任务也由尼克的同事完成。如果某任务于第PPP分钟开始，
时间管理题解
一个AFO的蒟蒻
07-03 560
题目大意 你有n个工作，同一时刻只能做一个任务，其中每个工作有其所需时间及完成的截止时间，问要完成所有工作，最迟要从什么时候开始。你最早可以从时间0开始工作。 输入格式 第一行一个整数n，表示任务数量,接下来M行，每行两个整数，Ti,Si，分别表示该任务的持续时间和截止时间。 输出格式 输出一个整数，表示最晚的开始时间，如果不能完成，输出-1. 样例输入 4 3 5 10 13 ...
第O题 巧用二进制解答 现在有n个货物，第i个货物的重量是。。。
超负荷运转
07-18 1689
现在有n个货物，第i个货物的重量是 2wi2wi 。每次搬的时候要求货物重量的总和是一个2的幂。问最少要搬几次能把所有的货物搬完。 样例解释： 1，1，2作为一组。 3，3作为一组。   Input 单组测试数据。  第一行有一个整数n (1≤n≤10^6)，表示有几个货物。  第二行有n个整数 w1,w2,...,wn，(0≤wi≤10^6)。 Output 输出最少的运货次数。...
NKOI 1047 任务安排
SuperGate的博客
06-13 1472
任务安排 Time Limit:1000MS  Memory Limit:65536K Total Submit:143 Accepted:70 Description N个任务排成一个序列在一台机器上等待完成（顺序不得改变），这N个任务被分成若干批，每批包含相邻的若干任务。从时刻0开始，这些任务被分批加工，第i个任务单独完成所需的时间是Ti。在每批任务开始前，机器需要启动时间S，而完成这
poj 1973 分配任务 进阶动态规划 <难题>
cfzjxz的专栏
04-02 2324
题意： 软件公司有两个项目，每个项目有m个子项目，有n个程序猿，每个程序猿完成项目A或者 项目B的某一个子项目时间为x, y 每个人同一时刻只能做一个项目 项目完成时间是最晚完成的A或者B的时间，也就是说提早完成米有用 求最快完成项目需要的时间 乍一看很想背包问题，不过一时间又不清楚如何切入，把时间作为体积，每个人完成项目可以出现的次数为 每个人的分组的上限个数（即m，这样不
高考日语模拟试题十六.pdf
04-02
高考日语模拟试题十六.pdf
高考日语模拟试题二十五.pdf
04-02
高考日语模拟试题二十五.pdf
高考日语模拟试题一-二十五参考答案.pdf
04-02
高考日语模拟试题一-二十五参考答案
高考日语模拟试题不含听力（三十九）.doc
04-02
这篇资料是针对高考日语学习者的模拟试题，主要考察日语阅读理解、词汇读音以及语法运用能力。试题包括选择题，涉及了日语词汇的正确读音、汉字书写、句子结构以及日常表达等多个方面。 16题考察的是词汇「目的」的...
新版助理电子商务师模拟试题.docx
最新发布
12-19
10. 消费者决策：对于犹豫不决的消费者，企业应设计完善的交互系统以提高网站信任度，促进购买决策。 11. 季节因素分析：季节因素分析属于整体销售分析的一部分，帮助企业了解不同季节销售趋势。 12. 价格区间分析...
最佳调度问题 与 工作分配问题（Java）
l870358133的博客
10-27 3409
最佳调度问题与工作分配问题乍一看像是两种题目，但实际上这两种问题在有些时候可以用相似的方法来解决（我遇到的这两个题目是用的同一种方法解决的，不确定是否所有的这两类问题方法都能共用），直接上题目了。 最佳调度问题 假设有n（n<=20）个任务由k（k<=20）个可并行工作的机器完成。完成任务i需要的时间为ti。 试设计一个算法，对任意给定的整数n和k，以及完成任务i 需要的时间为ti...
uvalive4254(贪心+优先队列)
潜水的程序猿
02-14 527
题意: 有n个任务,每个任务有ri,di,wi;代表任务的[ri,di]代表可以做这个任务的时间区间,而wi代表这个任务的工作量; 现在有有个处理器,如果它的执行速度是s,则完成第i个任务所需时间wi/s; 要求算出处理器执行过程中最大速度的最小值; 思路: 首先我们这题可以用二分枚举处理器最大速度,然后判断这个速度能不能满足条件; 那么怎么判断是否满足呢?就是按秒模拟时间,现
题解 [CQOI2015]任务查询系统
weixin_30491641的博客
06-06 91
题面 解析 首先,我们考虑下暴力的做法: 每次将一个任务的重要度加入到它的区间中, 询问的时候就直接加前\(k\)大. 然而,这样肯会炸的(都说了是暴力了). 其实,我们可以转化一下区间修改(因为区间修改似乎并不好做哈qwq) 利用前缀和与差分的思想(不会的请自行百度下), 将要修改的区间转化为单点修改, 于是,通过前缀和,我们就能知道一个点插入了哪些任务了. 然而怎么查询呢? 我们先考虑下对于一...
题解 P1280 【尼克的任务】
weixin_34124651的博客
05-07 114
传送门 f[i]表示i~n的最长空闲时间； 如果当前无任务就休息一秒（f[i]=f[i+1]+1）； 否则f[i]=max(f[i],f[i+当前工作时间]); 用结构体来记录，我们对于每一个时刻开一个数组来存以此时刻为起始点的所有任务，下标0来表示数组中的元素个数，便于遍历： #include<iostream>//简短的30行代码 #include<cstdi...
题解-工作分配
Ampty36的博客
06-09 641
工作分配 描述 2020 年，小信自己开了一家拥有 N 个员工的大公司。每天，小信都要分配 N 项工作给他的员工，但是，由于能力的不同，每个人对处理相同工作所需要的时间有快有慢。众所周知，小信是一个非常重视效率的人，他想知道该如何分配工作，才能使得完成所有工作的时间总和最小（每个员工只可以被分配到一个工作）。但是我们也都知道小信不是一般的懒，所以小信找到了你，请你拯救一下小信吧！ 输入 第一行输入...
LA 4254 贪心
weixin_34138521的博客
01-26 83
题意：有 n 个工作，他的允许的工作时间是 [l,r] ，工作量是 v ，求CPU最速度的最小值。 分析： 可能太久没有做题了，竟然脑子反应好慢的。还是很容易想到二分，但是二分怎么转移呢？ 可以看出，[l,r] 的区间范围不大，可以枚举，cpu 此时的二分答案 x，尽可能的贪心，怎么贪心呢，在同一速度情况下，是最先结束的优先。 而且，这一时刻，他能做很多任务，当 x 很大时，就在这里用优先...
bzoj 2034 [2009国家集训队]最大收益
weixin_30621959的博客
10-03 66
这个题，我想的是用一些神奇的线段树做法，根本没想匹配 但是好像很显然啊 (论文写的也太长了...) 给的l，r范围很大，其实有用的只有n个时刻 那可以先离散一下 然后把 各个线段按照权值从大到小排序，一个一个选 有矛盾一定选择权值大的，所以前面选定的集合一定是最优的 然后自己论文里说的check函数，看有没有空余的时刻，有就加上，没有就跳过 #include &...
51NOD 1099 任务执行顺序
YZ930035683的博客
08-13 73
来源：http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1099 前天没睡好 昨天做题闷闷沉沉的 好多一眼题 都瞎做了 这题今天早上发现其实 让执行空间大的 存储空间小的 先存储 这样有效空间就最大就好了 #include<bits/stdc++.h> using na...
[bzoj3932][CQOI2015]任务查询系统-题解[主席树][权值线段树]
weixin_30722589的博客
03-02 92
Description 最近实验室正在为其管理的超级计算机编制一套任务管理系统，而你被安排完成其中的查询部分。超级计算机中的 任务用三元组(Si,Ei,Pi)描述，(Si,Ei,Pi)表示任务从第Si秒开始，在第Ei秒后结束（第Si秒和Ei秒任务也在运行 ），其优先级为Pi。同一时间可能有多个任务同时执行，它们的优先级可能相同，也可能不同。调度系统会经常向 查询系统询问，第Xi秒正...
美团单车考试模拟试题-信息技术篇
11. 盘点日通常固定，如题目所述每月25日，确保统一进行盘点操作。 12. 配件发放应与Mola预判一致，以优化库存周转和满足需求。 13. 低值易耗品入库也需录入WMS，确保库存全面记录。 14. 配件仓布局需根据配件类型和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值