NOIP模拟题 2016.11.9 [动态规划] [数论] [二分答案] [启发式合并] [线段树] [树链剖分]

其他 2020-05-15 10:20:46 阅读次数: 0

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

T1：
三个串的LCS。。直接DP。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
const int INF=0x3f3f3f3f;
const int maxn = 125;
char X[maxn],Y[maxn],Z[maxn];
int dp[maxn][maxn][maxn];
int n;
int main()
{
    freopen("subq.in","r",stdin);
    freopen("subq.out","w",stdout);
    read(n);
    scanf("%s%s%s",X+1,Y+1,Z+1);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            for(int k=1;k<=n;k++)
            {
                smax(dp[i][j][k],maxx(dp[i-1][j][k],dp[i][j-1][k],dp[i][j][k-1]));
                if(X[i]==Y[j] && Y[j]==Z[k]) smax(dp[i][j][k],dp[i-1][j-1][k-1]+1);
            }
    printf("%d",dp[n][n][n]);
    return 0;
}

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

T2：
打质数表，然后直接前缀和。
二分最大的位置使得连续k个质数适合小于等于N

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
const int INF=0x3f3f3f3f;
const int maxn = 1200005;
const int N = 1200000;
bool no[maxn];
int prime[maxn],cnt;
LL sum[maxn];
void Euler()
{
    no[1] = true;
    for(int i=2;i<=N;i++)
    {
        if(!no[i]) prime[++cnt] = i;
        int j = 1;
        LL to = (LL) i * prime[j];
        while(j<=cnt && to<=N)
        {
            no[to] = true;
            if(i%prime[j] == 0) break;
            to = (LL) i * prime[++j];
        }
    }
    for(int i=1;i<=cnt;i++) sum[i] = sum[i-1] + prime[i];
}
int search(int l,int r,int n,int k)
{
    while(l < r)
    {
        int mid = (l+r+1)>>1;
        if(sum[mid+k] - sum[mid] <= n) l = mid;
        else r = mid - 1;
    }
    return l;
}
int main()
{
    freopen("dun.in","r",stdin);
    freopen("dun.out","w",stdout);
    Euler();
    int T;
    read(T);
    while(T--)
    {
        int n,k;
        read(n); read(k);
        if(!k) { printf("0\n");continue; }
        if(k > cnt) { printf("-1"); continue; }
        int pos = search(0,cnt-k,n,k);
        if(sum[pos+k]-sum[pos]<=n) printf(AUTO,sum[pos+k]-sum[pos]);
        else printf("-1");
        putchar('\n');
    }
    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

T3：
解法一：
首先应该想到树上差分，对于u,v之间加上一个种类为c的物品，那么 应该在u,v分别+1，到达LCA时先-1以保证LCA的正确性，最后返回上层时LCA再-1以完全消除u,v的影响。
但是有很多种类不能直接倍增，空间时间都无法承受。
所以每一个节点都是一棵线段树，直接在线段树上修改。
由于涉及到两棵树的合并，应采用启发式合并，把小的线段树合并到大的线段树上，然后把小的那棵树删掉，注意内存回收，不回收您懂的QWQ，并且要记得push！！！
实际上只用开两倍线段树的空间就可以了，因为每次只有两个有节点的线段树在占用内存。。
想到这里差不多就是就可以过了吧。。
然而。。GG
倍增的时候少打了个=。。。应该是>=好的吧。。
GGGG。。。。。。。。
数组开多大这个我是真的不知道。。
32倍GG3个点，100倍才过。。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
// end template

const int INF=0x3f3f3f3f;
const int maxn = 100005;
int n,q,Root,maxw;
int ans[maxn];

// original tree related
struct Edge
{
    int to,next;
}edge[maxn<<1];
int head[maxn];
int maxedge;
inline void addedge(int u,int v)
{
    edge[++maxedge] = (Edge) { v,head[u] };
    head[u] = maxedge;
    edge[++maxedge] = (Edge) { u,head[v] };
    head[v] = maxedge;
}
// end original tree

// LCA related
const int maxd = 18;
const int D = 17;
int fa[maxn][maxd];
int depth[maxn];
void lca(int u,int father,int deep)
{
    depth[u] = deep;
    for(int k=1;k<=D;k++) fa[u][k] = fa[fa[u][k-1]][k-1];
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v == father) continue;
        fa[v][0] = u;
        lca(v,u,deep+1);
    }
}
int LCA(int u,int v)
{
    if(u == v) return u;
    if(depth[u] < depth[v]) swap(u,v);
    for(int k=D;k>=0;k--) if(depth[fa[u][k]] >= depth[v])
        u = fa[u][k];
    if(u == v) return u;
    for(int k=D;k>=0;k--) if(fa[u][k] ^ fa[v][k])
        u = fa[u][k] , v = fa[v][k];
    return fa[u][0];
}
// end LCA

// segment tree related
struct Node
{
    int ch[2];
    int pos,val; // the maxnode under this one and its value
    int size; // set for faster merge
}node[maxn<<5];
#define ch(x,d) node[x].ch[d]
#define size(x) node[x].size
#define pos(x) node[x].pos
#define val(x) node[x].val
int maxnode;
int sta[maxn<<5],top;
inline int require()
{
    int root;
    if(top) root = sta[top--];
    else root = ++maxnode;
    return root;
}
void recycle(int &root)
{
    if(!root) return;
    recycle(ch(root,0));
    recycle(ch(root,1));
    pos(root) = val(root) = 0;
    size(root) = 0;
    sta[++top] = root;
    root = 0;
}
inline void update(int root)
{
    size(root) = size(ch(root,0)) + size(ch(root,1));
    int lson = ch(root,0);
    int rson = ch(root,1);
    int rt = val(lson)>val(rson) || (val(lson)==val(rson)&&pos(lson)<pos(rson)) ? lson : rson; // the minimum type is required
    val(root) = val(rt);
    pos(root) = pos(rt);
}
void modify(int &root,int l,int r,int pos,int val)
{
    if(!root) root = require();
    if(l == r)
    {
        val(root) += val;
        pos(root) = l;
        size(root) = !!val(root);
        return;
    }
    int mid = (l+r)>>1;
    if(pos<=mid) modify(ch(root,0),l,mid,pos,val);
    else modify(ch(root,1),mid+1,r,pos,val);
    update(root);
}
void merge(int rt,int root,int l,int r)
{
    if(!size(root)) return;
    if(l == r)
    {
        modify(rt,1,maxw,l,val(root));
        return;
    }
    int mid = (l+r)>>1;
    merge(rt,ch(root,0),l,mid);
    merge(rt,ch(root,1),mid+1,r);
}
int ultra(int root1,int root2) // root2 to root1
{
    if(size(root1) < size(root2)) swap(root1,root2);
    merge(root1,root2,1,maxw);
    recycle(root2);
    return root1;
}
// end segment tree

// delta related
struct Delta
{
    int next;
    int pos;
    int val;
}delta[maxn<<2];
int d_pre[maxn],d_post[maxn];
int maxdelta;
inline void addpre(int u,int pos,int val)
{
    delta[++maxdelta] = (Delta) { d_pre[u],pos,val };
    d_pre[u] = maxdelta;
}
inline void addpost(int u,int pos,int val)
{
    delta[++maxdelta] = (Delta) { d_post[u],pos,val };
    d_post[u] = maxdelta;
}
// end delta

// main
inline void init()
{
    memset(head,-1,sizeof(head)); maxedge=-1;
    memset(d_pre,-1,sizeof(d_pre));
    memset(d_post,-1,sizeof(d_post));
    maxdelta=-1;
    read(n); read(q); Root = (n+1)>>1;
    for(int i=1;i<n;i++)
    {
        int x,y;
        read(x); read(y);
        addedge(x,y);
    }
    lca(Root,-1,1);
}
void delta_composition()
{
    for(int i=1;i<=q;i++)
    {
        int x,y,w;
        read(x),read(y),read(w); smax(maxw,w);
        int the_lca = LCA(x,y);
        addpre(x,w,1); addpre(y,w,1);
        addpre(the_lca,w,-1); addpost(the_lca,w,-1);
    }
}
int dfs(int u,int father)
{
    int root = require();
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v == father) continue;
        root = ultra(dfs(v,u),root);
    }
    for(int i=d_pre[u];~i;i=delta[i].next)
        modify(root,1,maxw,delta[i].pos,delta[i].val);
    ans[u] = pos(root);
    for(int i=d_post[u];~i;i=delta[i].next)
        modify(root,1,maxw,delta[i].pos,delta[i].val);
    return root;
}
void work()
{
    dfs(Root,-1);
    for(int i=1;i<=n;i++) printf("%d\n",ans[i]);
}
int main()
{
    freopen("rice.in","r",stdin);
    freopen("rice.out","w",stdout);
    init();
    delta_composition();
    work();
    return 0;
}

解法二：
树链剖分，只不过不用线段树维护树链，而是用维护当前颜色最大值。
按照特定的dfs序，把所有的区间更新变成差分序列，然后在dfs序列上求前缀和。
在top+1，然后在u的下一个节点-1

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<iomanip>
#include<ctime>
#include<cctype>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
using namespace std;
#define smax(x,tmp) x=max((x),(tmp))
#define smin(x,tmp) x=min((x),(tmp))
#define maxx(x1,x2,x3) max(max(x1,x2),x3)
#define minn(x1,x2,x3) min(min(x1,x2),x3)
typedef long long LL;
template <class T> inline void read(T &x)
{
    x = 0;
    T flag = 1;
    char ch = (char)getchar();
    while(ch<'0' || ch>'9')
    {
        if(ch == '-') flag = -1;
        ch = (char)getchar();
    }
    while(ch>='0' && ch<='9')
    {
        x = (x<<1) + (x<<3) + ch - '0';
        ch = (char)getchar();
    }
    x *= flag;
}
template <class T> T gcd(T a,T b) { return !b?a:gcd(b,a%b); }
const int INF=0x3f3f3f3f;
const int maxn = 100005;
struct Edge
{
    int to,next;
}edge[maxn<<1];
int head[maxn];
int maxedge;
inline void addedge(int u,int v)
{
    edge[++maxedge] = (Edge) { v,head[u] };
    head[u] = maxedge;
    edge[++maxedge] = (Edge) { u,head[v] };
    head[v] = maxedge;
}
struct Delta
{
    int next;
    int pos,val;
}delta[maxn<<5];
int delta_head[maxn];
int maxdelta;
inline void adddelta(int u,int pos,int val)
{
    delta[++maxdelta] = (Delta) { delta_head[u],pos,val };
    delta_head[u] = maxdelta;
}
struct Node
{
    int val,pos;
}node[maxn<<2];
#define val(x) node[x].val
#define pos(x) node[x].pos
int rid[maxn];
int maxnode;
int fa[maxn],son[maxn],depth[maxn],size[maxn];
int top[maxn],id[maxn];
void dfs1(int u,int father,int deep)
{
    fa[u] = father; depth[u] = deep; size[u] = 1;
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v == father) continue;
        dfs1(v,u,deep+1);
        size[u] += size[v];
        if(!son[u] || size[son[u]]<size[v]) son[u] = v;
    }
}
void dfs2(int u,int tp)
{
    top[u] = tp; id[u] = ++maxnode; rid[maxnode] = u;
    if(son[u]) dfs2(son[u],tp);
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v == fa[u] || v == son[u]) continue;
        dfs2(v,v);
    }
}
inline void update(int root)
{
    int x = val(root<<1) >= val(root<<1|1) ? (root<<1) : (root<<1|1);
    val(root) = val(x);
    pos(root) = pos(x);
}
void modify(int root,int l,int r,int pos,int val)
{
    if(l == r)
    {
        val(root) += val;
        pos(root) = val(root)? l : 0;
        return;
    }
    int mid = (l+r)>>1;
    if(pos <= mid) modify(root<<1,l,mid,pos,val);
    else modify(root<<1|1,mid+1,r,pos,val);
    update(root);
}
int n,q,Root,maxw;
int ans[maxn];
void Delta_composition(int u,int v,int pos)
{
    int tp1 = top[u] , tp2 = top[v];
    while(tp1 ^ tp2)
    {
        if(depth[tp1] < depth[tp2]) swap(u,v) , swap(tp1,tp2);
        adddelta(rid[id[tp1]],pos,1);
        adddelta(rid[id[u]+1],pos,-1);
        u = fa[tp1];
        tp1 = top[u];
    }
    if(depth[u] < depth[v]) swap(u,v);
    adddelta(rid[id[v]],pos,1);
    adddelta(rid[id[u]+1],pos,-1);
}
void dfs(int u)
{
    for(int i=delta_head[u];~i;i=delta[i].next)
        modify(1,1,maxw,delta[i].pos,delta[i].val);
    ans[u] = pos(1);
    if(son[u]) dfs(son[u]);
    for(int i=head[u];~i;i=edge[i].next)
    {
        int v = edge[i].to;
        if(v == fa[u] || v == son[u]) continue;
        dfs(v);
    }
}
inline bool init()
{
    if(!~scanf("%d%d",&n,&q) || (!n&&!q)) return false;
    Root = (n+1)>>1;
    memset(head,-1,sizeof(head)); maxedge=-1;
    memset(delta_head,-1,sizeof(delta_head)); maxdelta=-1;
    memset(node,0,sizeof(node));
    memset(son,0,sizeof(son));
    maxnode = 0;
    for(int i=1;i<n;i++)
    {
        int x,y;
        read(x); read(y);
        addedge(x,y);
    }
    dfs1(Root,-1,1);
    dfs2(Root,Root);
    for(int i=1;i<=q;i++)
    {
        int u,v,w;
        read(u); read(v); read(w); smax(maxw,w);
        Delta_composition(u,v,w);
    }
    return true;
}
void work()
{
    dfs(Root);
    for(int i=1;i<=n;i++) printf("%d\n",ans[i]);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("rice.in","r",stdin);
    freopen("rice.out","w",stdout);
#endif
    while(init()) work();
    return 0;
}
JacquesdeH
原创文章 152 获赞 15 访问量 6万+
关注 私信

猜你喜欢

转载自blog.csdn.net/ourfutr2330/article/details/53099643
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022