[NOIP模拟题][DP][水题][数学][树链剖分][差分序列]

最新推荐文章于 2020-10-24 23:26:45 发布

Youga_

最新推荐文章于 2020-10-24 23:26:45 发布

阅读量335

点赞数

分类专栏：动态规划水题数学树链剖分差分序列

本文链接：https://blog.csdn.net/yznoi2017/article/details/53103692

版权

动态规划同时被 3 个专栏收录

16 篇文章 0 订阅

订阅专栏

数学

4 篇文章 0 订阅

订阅专栏

差分序列

4 篇文章 0 订阅

订阅专栏

描述
给定3个字符串，求它们的最长公共子序列。
输入
第一行一个整数n，表示三个字符串的长度
接下来三行，每行是一个长度为n只包含小写字母的字符串。
输出
输出最长公共子序列的长度。
输入样例
4
abac
abbc
cbca
输出样例
2
提示
30% n<=10
100% n<=120

水题一道，把经典的LCS问题改成三维即可

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=120+5;
int n,f[maxn][maxn][maxn];
char A[maxn],B[maxn],C[maxn];
int query(int a,int b,int c)
{
    int temp1=max(a,b),temp2=max(b,c);
    return max(temp1,temp2);
}
int main()
{
    freopen("subq.in","r",stdin);
    freopen("subq.out","w",stdout);
    scanf("%d %s %s %s",&n,A+1,B+1,C+1);
    for (int i=1;i<=n;i++)
      for (int j=1;j<=n;j++)
        for (int k=1;k<=n;k++)
        {
            if (A[i]==B[j]&&B[j]==C[k]) f[i][j][k]=f[i-1][j-1][k-1]+1;
            else f[i][j][k]=query(f[i-1][j][k],f[i][j-1][k],f[i][j][k-1]);
        }
    printf("%d",f[n][n][n]);
    return 0;
}

【问题描述】
定义两个素数是连续的当且仅当这两个素数之间不存在其他的素数（如 7,11 ,(23,29)。给定��,��，在不超过��的正整数中求能够分解为��个连续的素数的和的最大的那个是多少。
【输入格式】
第一行一个正整数��代表数据组数。
接下来��行每行两个正整数��,��代表一组询问。
【输出格式】
输出共��行，每行一个整数代表答案；如果找不到这样的数，输出−1。
【样例输入】
3
20 2
20 3
20 4
【样例输出】
18
15
17
【样例解释】
╭︿︿︿╮
{/ o o /}
( (oo) )
︶︶︶
【数据规模与约定】
对于20%的数据，1≤��≤100。
对于40%的数据，��=1。
对于60%的数据，所有的询问的��相等。
对于100%的数据，1≤��<2000,1≤��≤106。

数学乱搞题
首先打个线性筛， $10^6以内$ 大概只有7W多个素数，我们对素数做个前缀和，然后就可以愉快的枚举了
好吧，我都在考虑单调性用二分查找了，结果还是搞忘二分，不过数据还是不是很强，我还是可以AC的

#include<cstdio>
#include<cstring>
#include<cctype>
#include<algorithm>
#define LL long long 
using namespace std;
const int N=1e6;
int prime[N+5],cnt,n,k,T,ans,pos;
bool mark[N+5];
LL sum[N+5];
int readint()
{
    int x=0; char ch=getchar();
    while (!isdigit(ch)) ch=getchar();
    while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0'; ch=getchar();}
    return x;
}
void init()
{
    for (int i=2;i<=N;i++)
    {
        if (!mark[i]) prime[++cnt]=i;
        for (int j=1;j<=cnt;j++)
        {
            if (i*prime[j]>N) break;
            mark[i*prime[j]]=true;
            if (i%prime[j]==0) break;
        }
    }
    for (int i=1;i<=cnt;i++) sum[i]=sum[i-1]+prime[i];
}
int main()
{
    freopen("dun.in","r",stdin);
    freopen("dun.out","w",stdout);
    init(); T=readint();
    while (T--)
    {
        n=readint(); k=readint(); ans=-1;
        pos=upper_bound(prime+1,prime+cnt+1,n)-prime-1;
        for (int i=pos;i>=k;i--) if (sum[i]-sum[i-k]<=n)
        {
            ans=sum[i]-sum[i-k];
            break;
        }
        printf("%d\n",ans);
    }
    return 0;
}

发放粮食
描述
有一个村庄在闹饥荒，善良而土豪的YGH决定给他们发放救济粮，该村庄有 n 户人家，每两户人家之间只有一条路可以互相到达，即这些人家之间形成一棵树。现在 YGH 会以这样的形式给他们发放粮食，选择两户人家，然后对这两个户人家路径上的所有人家都发放一袋种类为 w 的救济粮。在完成一系列发放任务后，YGH 想知道每一户人家收到的粮食中数量最多的是哪一种。
输入
第一行两个数 n，q，其中 n 表示村庄共有几户人家，q 表示 YGH 一共发放了几次粮食。接下来 n-1 行，每行两个数 x y，表示编号为 x 和 y 的两户人家之间连有边。接下来 q 行，每行三个数 x y w，表示 YGH 选择了 x 到 y 的路径，对每户人家发放 1 袋种类为 w 的粮食。
输出
输出 n 行，第 i 行输出编号为 i 的人家收到的粮食中数量最多的种类号，如果有多个数量相同的粮食，输出其中最小的种类号，如果没有收到粮食，输出0
样例输入
[1]
2 4
1 2
1 1 1
1 2 2
2 2 2
2 2 1
[2]
5 3
1 2
3 1
3 4
5 3
2 3 3
1 5 2
3 3 3
样例输出
[1]
1
2
[2]
2
3
3
0
2
提示
对于 40% 的数据 n<=1000，q<=1000，1<=w<=1000
对于 100% 的数据 n<=100000，q<=100000，1<=w<=100000 1<=x，y<=n

原题请见HDU5029
40%随便暴力可过
对于100%数据就有点难搞了
首先我们把这个问题简化到一条链上：对于一条链，选定一些区间染色，求每个点被染得最多的颜色，我们可以考虑差分，对于一次染色操作[u,v,w]在u地方做个标记push(w)，在v+1 push(-w）,记下所有标记后，我们将区间从左向右扫描，记sum[i]为i颜色总数，那么进行完所有u的操作后，sum最大的就是u对应的答案
将问题放在树上后我们就可以先进行树链剖分，然后同理的操作，不过这里数据较大，但上述操作只有2*m次，所以就可以开链表vector之类的来储存

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cctype>
#include<vector>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")  
const int maxn=1e5+5;
int n,m,edge,to[maxn<<1],nxt[maxn<<1],head[maxn],fa[maxn],dep[maxn],size[maxn],son[maxn];
int dfn[maxn],cnt,reflect[maxn],top[maxn],maxkind,ans[maxn];
struct Node
{
    int L,R,val,key;
}node[maxn<<2];
#define Lson(x) (x<<1)
#define Rson(x) (x<<1|1)
vector<int>opt[maxn];
int readint()
{
    int x=0; char ch=getchar();
    while (!isdigit(ch)) ch=getchar();
    while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0'; ch=getchar();}
    return x;
}
void edge_add(int u,int v)
{
    to[++edge]=v; nxt[edge]=head[u]; head[u]=edge;
}
void dfs1(int u)
{
    size[u]=1;
    for (int E=head[u];E;E=nxt[E])
    {
        int v=to[E];
        if (v==fa[u]) continue;
        fa[v]=u; dep[v]=dep[u]+1; dfs1(v);
        size[u]+=size[v];
        if (size[v]>size[son[u]]) son[u]=v;
    }
}
void dfs2(int u,int tp)
{
    dfn[u]=++cnt; top[u]=tp; reflect[cnt]=u;
    if (son[u]) dfs2(son[u],tp);
    for (int E=head[u];E;E=nxt[E])
    {
        int v=to[E];
        if (v==fa[u]||v==son[u]) continue;
        dfs2(v,v);
    }
} 
void init(int u,int v,int kind)
{
    opt[u].push_back(kind);  
    opt[v+1].push_back(-kind);  
}
void seg_get(int u,int v,int kind)
{
    int tp1=top[u],tp2=top[v];
    while (tp1^tp2)
    {
        if (dep[tp1]<dep[tp2]) swap(tp1,tp2),swap(u,v);
        init(dfn[tp1],dfn[u],kind); u=fa[tp1]; tp1=top[u];
    }
    if(dep[u]>dep[v]) swap(u,v);
    init(dfn[u],dfn[v],kind); 
}
void pushup(int tr)
{
    node[tr].key=node[Rson(tr)].val>node[Lson(tr)].val?node[Rson(tr)].key:node[Lson(tr)].key;
    node[tr].val=max(node[Lson(tr)].val,node[Rson(tr)].val); 
}
void build(int L,int R,int tr)
{
    node[tr].L=L; node[tr].R=R;    
    if(L==R)    
    {  
        node[tr].key=L;  
        return;  
    }  
    int mid=(L+R)>>1;  
    build(L,mid,Lson(tr)); build(mid+1,R,Rson(tr));  
    pushup(tr); 
}
void update(int tr,int pos,int add)  
{  
    if(node[tr].L==pos&&node[tr].R==pos)  
    {  
        node[tr].val+=add;  
        return;  
    }  
    if(node[Lson(tr)].R>=pos) update(Lson(tr),pos,add);  
    else update(Rson(tr),pos,add);  
    pushup(tr);  
}  
int main()
{
    freopen("rice.in","r",stdin);
    freopen("rice.out","w",stdout);
    n=readint(); m=readint();
    for (int i=1;i<n;i++)
    {
        int u=readint(),v=readint();
        edge_add(u,v); edge_add(v,u);
    }
    dep[1]=1; dfs1(1); dfs2(1,1);
    for (int i=1;i<=m;i++)
    {
        int u=readint(),v=readint(),kind=readint();
        seg_get(u,v,kind); 
        maxkind=max(maxkind,kind);
    }
    build(1,maxkind,1);
    for (int i=1;i<=n;i++)
    {
        int siz=opt[i].size();
        for (int j=0;j<siz;j++)
        {
            int temp=opt[i][j];
            if (temp<0) update(1,-temp,-1);
            else update(1,temp,1);
        }
        ans[reflect[i]]=node[1].key;
        if (node[1].val==0) ans[reflect[i]]=0;
    }
    for (int i=1;i<=n;i++) printf("%d\n",ans[i]);
    return 0;
}