[NOIP模拟][LCS][二分][树链剖分][hdu5029]

最新推荐文章于 2020-12-20 19:24:33 发布
最新推荐文章于 2020-12-20 19:24:33 发布
阅读量491 收藏 1
点赞数
分类专栏： NOIP 树链剖分 LCS 二分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lfrun/article/details/53114388
版权
NOIP 同时被 3 个专栏收录
10 篇文章 0 订阅
订阅专栏
二分
7 篇文章 0 订阅
订阅专栏
LCS
3 篇文章 0 订阅
订阅专栏

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

就是LCS 3维。。。，方程还是原来的他。。

T2：dun
【问题描述】
定义两个素数是连续的当且仅当这两个素数之间不存在其他的素数（如 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。

打出素数表，然后二分查找就好了。。。

#include<iostream>
#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<string>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
#define INF 0x3f3f3f3f
#define clock CLOCKS_PER_SEC
#define cle(x) memset(x,0,sizeof(x))
#define maxcle(x) memset(x,127,sizeof(x))
#define mincle(x) memset(x,-1,sizeof(x))
#define cop(a,x) memcpy(x,a,sizeof(a))
#define FROP "dun"
#define C(a,b) next_permutation(a,b)
#define LL long long
#define smin(x,tmp) x=min(x,tmp)
#define maxx(x1,x2,x3) max(x1,max(x2,x3))
using namespace std;
const int N=80005,W=1e6;
int ss[N],tot,T,n,k;
bool vis[W+5];
LL sum[N];
void mack_ss()
{
    int q=sqrt(W+0.5);
    for(int j = 2; j <= q ; j++)
        for(int i = j * 2 ; i <= 1e6 ; i+=j)
        if(i%j==0&&!vis[i])
            vis[i]=true;
    vis[2]=false;
    vis[1]=true;
    for(int i = 1; i <= 1e6;i++)if(!vis[i])
            ss[++tot]=i;
    for(int i = 1; i <= tot;i++)
        sum[i]=sum[i-1]+ss[i];
}
int find(int x){
    int l=1,r=tot,ans;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(ss[mid]>=x)ans=mid,r=mid-1;
        else l=mid+1;
    }
    return ans;
}
int main()
{
    freopen(FROP".in","r",stdin);
    freopen(FROP".out","w",stdout);
    scanf("%d",&T);
    mack_ss();
    while(T--)
    {
        scanf("%d%d",&n,&k);
        int tmp=n/k;
        if(k*tmp!=n)tmp++;
        int w=find(tmp);
        LL ans=-1;
        for(int i = w, j = w+k-1; i >=1&&j>=1;i--,j--)
            if(sum[j]-sum[i-1]<=n)
            {
                ans=sum[j]-sum[i-1];
                break;
            }
        printf(AUTO"\n",ans);
    }
    return 0;
}

T3：发放粮食
描述
有一个村庄在闹饥荒，善良而土豪的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

是hdu5209原题，，还不会树链剖分，所以就用差分写的过了40

#include<iostream>
#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<string>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
#define INF 0x3f3f3f3f
#define clock CLOCKS_PER_SEC
#define cle(x) memset(x,0,sizeof(x))
#define maxcle(x) memset(x,127,sizeof(x))
#define mincle(x) memset(x,-1,sizeof(x))
#define cop(a,x) memcpy(x,a,sizeof(a))
#define FROP "rice"
#define C(a,b) next_permutation(a,b)
#define LL long long
#define smin(x,tmp) x=min(x,tmp)
#define maxx(x1,x2,x3) max(x1,max(x2,x3))
using namespace std;
const int N=1e5+55;
int readin()
{
    int res=0;
    char ch=getchar();
    while(ch>'9'||ch<'0')ch=getchar();
    while(ch>='0'&&ch<='9'){res=res*10+ch-'0';ch=getchar();}
    return res;
}
struct ii
{
    int to,ne;
    ii(int to=0,int ne=0):to(to),ne(ne){ }
}ed[N*2];
struct qq
{
    int to,ne;
    qq(int to=0,int ne=0):to(to),ne(ne){ }
}que[N*2];
struct aa
{
    int x,y,w,lca;
    aa(int x=0,int y=0,int w=0):x(x),y(y),w(w){ }
    bool operator <(const aa &a)const
    {
        return w<a.w;
    }
}Q[N];
int head[N],fa[N],ufa[N],fir[N],n,q,vis[N];
int chan(int x){if(x%2)return (x+1)/2;return x/2;}
int find_fa(int x){return x==ufa[x]?x:ufa[x]=find_fa(ufa[x]);}
void init()
{
    n=readin(),q=readin();
    for(int i = 1; i <= n-1; i++)
    {
        int x=readin(),y=readin();
        ed[i*2-1]=ii(y,head[x]);
        head[x]=i*2-1;
        ed[i*2]=ii(x,head[y]);
        head[y]=i*2;
    }
    for(int i = 1; i <= q; i++)
    {
        int x=readin(),y=readin(),w=readin();
        que[i*2-1]=qq(x,fir[y]);
        fir[y]=i*2-1;
        que[i*2]=qq(y,fir[x]);
        fir[x]=i*2;
        Q[i]=aa(x,y,w);
    }
}
void tarjian(int u)
{
    ufa[u]=u;
    vis[u]=true;
    for(int i = head[u] ; i ; i =ed[i].ne)
    {
        int v=ed[i].to;
        if(fa[u]==v)continue;
        fa[v]=u;
        tarjian(v);
        ufa[v]=u;
    }
    for(int i = fir[u] ; i ; i = que[i].ne)
    {
        int v=que[i].to;
        if(!vis[v])continue;
        int p=chan(i);
        Q[p].lca=find_fa(v);
    }
}
int answ[N],ans[N];
int mer[N];
void cal(int x,int w)
{
    for(int i = head[x]; i ; i=ed[i].ne)
    {
        int v=ed[i].to;
        if(v==fa[x])continue;
        cal(v,w);
        mer[x]+=mer[v];
    }
    if(mer[x]==answ[x])smin(ans[x],w);
    else if(mer[x]>answ[x])
    {
        answ[x]=mer[x];
        ans[x]=w;
    }
}
void work()
{
    sort(Q+1,Q+q+1);
    int flag=Q[1].w;
    for(int i = 1; i <= q; i++)
    {
        if(flag!=Q[i].w)
        {
            cal(1,flag);
            flag=Q[i].w;
            cle(mer);
        }
        int x=Q[i].x,y=Q[i].y,lca=Q[i].lca;
        mer[x]++,mer[y]++,mer[lca]--;
        if(fa[lca])mer[fa[lca]]--;
    }
    cal(1,flag);
    for(int i = 1; i <= n; i++)
        printf("%d\n",ans[i]);
}
int main()
{
    freopen(FROP".in","r",stdin);
    freopen(FROP".out","w",stdout);
    init();
    tarjian(1);
    work();
    return 0;
}
/*
13 3
1 2 
1 3
2 3
2 5
6 3
7 3
8 4
4 9
8 10
8 11
9 12
9 13
10 5 100
12 6 100
6 7 20
*/

然后又把树链给学了，写了QAQ

#pragma comment(linker, "/STACK:1024000000,1024000000")  
#include<iostream>
#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<string>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
#define INF 0x3f3f3f3f
#define clock CLOCKS_PER_SEC
#define cle(x) memset(x,0,sizeof(x))
#define maxcle(x) memset(x,127,sizeof(x))
#define mincle(x) memset(x,-1,sizeof(x))
#define minn(x1,x2,x3) min(x1,min(x2,x3))
#define cop(a,x) memcpy(x,a,sizeof(a))
#define FROP "rice"
#define C(a,b) next_permutation(a,b)
#define LL long long
#define smin(x,tmp) x=min(x,tmp)
using namespace std;
const int N=100010;
struct ii
{
    int to,ne;
    ii(int to=0,int ne=0):to(to),ne(ne){ }
}ed[N*2];
struct node
{
    int l,r;
    int val,key;
    node(int val=0,int key=0):val(val),key(key){ }
}col[N*4];
#define L(x) x<<1
#define R(x) (x<<1)|1
int fir[N],fa[N],son[N],top[N],tid[N],_tid[N],dep[N],siz[N],Index,n,m;
void dfs1(int u)
{
    siz[u]=1;
    for(int i =fir[u];i;i=ed[i].ne)
    {
        int v=ed[i].to;
        if(fa[u]==v)continue;
        fa[v]=u;
        dep[v]=dep[u]+1;
        dfs1(v);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]])
            son[u]=v;
    }
}
void dfs2(int u,int tp)
{
    top[u]=tp;
    tid[u]=++Index;
    _tid[Index]=u;
    if(!son[u])return;
    dfs2(son[u],tp);
    for(int i = fir[u];i;i=ed[i].ne)
    {
        int v=ed[i].to;
        if(fa[u]==v||son[u]==v)continue;
        dfs2(v,v);
    }
}
#define val(x) col[x].val
#define key(x) col[x].key
#define l(x) col[x].l
#define r(x) col[x].r
void pushup(int u)
{
    val(u)=max(col[L(u)].val,col[R(u)].val);
    key(u)=val(R(u))>val(L(u))?key(R(u)):key(L(u));
}
void build(int l,int r,int u)
{
    l(u)=l,r(u)=r;
    if(l==r)
    {
        key(u)=l;
        return;
    }
    int mid=(l+r)>>1;
    build(l,mid,L(u));
    build(mid+1,r,R(u));
}
void update(int tr,int pos,int v)
{
    if(l(tr)==pos&&pos==r(tr))
    {
        val(tr)+=v;
        return;
    }
    int mid=( l(tr) + r(tr) )>>1;
    if(mid>=pos)update(L(tr),pos,v);
    else update(R(tr),pos,v);
    pushup(tr);
}
vector<int>opt[N];
void sum(int x,int y,int v)
{
    opt[x].push_back(v);
    opt[y+1].push_back(-v);
}
void change(int x,int y,int v)
{
    int f1=top[x],f2=top[y];
    while(f1^f2)
    {
        if(dep[f1]<dep[f2])swap(f1,f2),swap(x,y);
        sum(tid[f1],tid[x],v);
        x=fa[f1];
        f1=top[x];
    }
    if(dep[x]>dep[y])swap(x,y);
    sum(tid[x],tid[y],v);
}
void init()
{
    scanf("%d%d",&n,&m);
    for(int i = 1; i <= n-1; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        ed[i*2-1]=ii(y,fir[x]);
        fir[x]=i*2-1;
        ed[i*2]=ii(x,fir[y]);
        fir[y]=i*2;
    }
    dep[1]=1;dfs1(1),dfs2(1,1);
    int maxx=0;
    for(int i = 1; i <= m; i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        maxx=max(z,maxx);
        change(x,y,z);
    }
    build(1,maxx,1);
}
int ans[N];
void work()
{
    for(int i = 1; i<=n; i++)
    {
        int sz=opt[i].size();
        for(int j = 0; j<sz;j++)
        {
            int tmp=opt[i][j];
            if(tmp<0)update(1,-tmp,-1);
            else update(1,tmp,1);
        }
        ans[_tid[i]]=val(1)==0?0:key(1);
    }
    for(int i = 1; i<= n; i++)
        printf("%d\n",ans[i]);
}
int main()
{
    freopen(FROP".in","r",stdin);
    freopen(FROP".out","w",stdout);
    init();
    work();
    return 0;
}
Freddddddddddd
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
最长公共子序列LCS和 最长单调子序列 及其二分优化
m0_60777643的博客
04-07 2088
最长公共子序列LCS和最长上升子序列LIS都是动态规划的经典例题，再度回顾这两个例题，已经有了更深一些的理解和优化方式。这里系统整理一下 。 一.最长单调子序列 1.最长上升子序列 最朴素的dp思路，就是对一个序列a[i]，设一个dp数组, 其中dp[i]的含义为以a[i]结尾的最长上升子序列的长度。 那么我们考虑当前的a[i]与与a[i]之前的元素的关系， 如果当前的a[i]与a[i]之前的a[j]满足递增关系，那么dp[i]的状态可以由dp[j]得到，对每个先前状态取最值即为当前状态的最.
关于特殊的LCS问题的优化
weixin_34111819的博客
09-16 157
首先是一道比较简单的例题：传送门 题目的提示很明显，元素无重复，然后看看样例，手玩一下，就会发现选的元素在上面对应着上升的位置，而且这还是两个排列，那么就可以建立一个从排列A到排列B的映射，然后就可以转化成为LIS问题了，这个问题是有O(nlogn)的解法的。 代码： #include<cstdio> using namespace std;...
【20161109NOIP%你题】【LCS】子序列题解
It's Maverick.
11-09 618
离NOIP复赛还有10天。啊啊啊啊啊啊啊啊啊！
【noip模拟题】[dp][二分][树链剖分][hdu5029][线段树]
Sue2333的博客
11-10 623
T1 描述 给定3个字符串，求它们的最长公共子序列。 输入 第一行一个整数n，表示三个字符串的长度 接下来三行，每行是一个长度为n只包含小写字母的字符串。 输出 输出最长公共子序列的长度。 输入样例 4 abac abbc cbca 输出样例 2 提示 30% n<=10
LIS,LCS,LICS 学习笔记
Tricksterism
02-21 918
LIS,LCS,LICS 学习笔记 1.最长上升子序列（LIS） 子序列： 1.可以不连续 2.相对位置不变 dp[i][j] 表示前i位置，最大值为j的LIS长度 1. dp[i-1][j] 前i-1位置，最大值为j的LIS长度 (没有考虑a[i]) 2. dp[i][j]=dp[i-1][k]+1 ...
NOIP树链剖分习题讲解报告
11-01
P2590 [ZJOI2008]树的统计 P3384 【模板】轻重链剖分/树链剖分 P3950 部落冲突 P4092 [HEOI2016/TJOI2016]树 P2146 [NOI2015] 软件包管理器
NOIP模拟题一套
05-16
NOIP2017模拟题，带题面，数据，标程，题解。 难度与联赛相近，考点均在联赛范围内 NOIP2017模拟题，带题面，数据，标程，题解。 难度与联赛相近，考点均在联赛范围内
noip模拟题10
05-01
noip模拟题（有数据，有代码，有题解报告）
noip模拟题16
05-03
noip模拟题（有数据，有代码，有解题报告）
hdu 4729 树链剖分+二分
生活总是要微笑着面对~
10-14 1677
此题一看就知道是树链剖分，模板题！可怜我模板少抄个字母，在这两百多行的代码里找bug找了三个多小时啊！！！！ 解题思路：对于要求的x，y点，先可以求得不加任何操作的最大流量P，c1为建造一个路的话费，c2为增加一个容量的花费，如果c1P+k/c1。 否则，如果先建一条路，那么最大的流量是M=P+1+（k-c1）/c2，如果不新建路只加边呢？那就可以二分求得最大的结果，为了节省时间，可以对整体进
2015.11.1 XJOJ(NOIP模拟赛)总结
weixin_30564785的博客
11-01 138
第一题：第一遍看没看懂题，然后就继续看剩下的题目，看完了再回来看这道题，也是花费了想象力才搞懂他在说什么。但是没有想法，无奈暴搜。按照给出的权值(G)，硬着枚举排列，再check逆序对的数量。 O(n!n(logn)) 30分 第二题：一棵树，然后呢？？？没办法，就硬着做了。30分 第三题：最简单的一道题，既然没得分。本来写了个人工比较，得出匹配的数的东西，但是好像写挂了...
UVaOJ699---The Falling Leaves
c随遇er安的专栏
03-31 643
699 - The Falling Leaves Time limit: 3.000 seconds Each year, fall in the North Central region is accompanied by the brilliant colors of the leaves on the trees, followed quickly by the falling
通俗理解动态规划：由浅入深DP并解决LCS问题(23年修订版)
热门推荐
结构之法 算法之道
12-31 11万+
动态规划算法解LCS问题作者 July 二零一零年十二月三十一日本文参考：微软面试100题系列V0.1版第19、56题、算法导论、维基百科。第一部分、什么是动态规划算法 ok，咱们先来了解下什么是动态规划算法。 动态规划一般也只能应用于有最优子结构的问题。最优子结构的意思是局部最优解能决定全局最优解(对有些问题这个要求并不能完全满足，故有时需要引入一定的近似)。简单地说，问题能
刷屏专用超长复制_跪求超超长刷屏字符剑。。
weixin_39629352的博客
12-20 4万+
该楼层疑似违规已被系统折叠隐藏此楼查看此楼....飘过.....飘过......飘过.......飘过........飘过........飘过........飘过........飘过.......飘过......飘过.....飘过....飘过...飘过..飘过.飘过.飘过.飘过..飘过...飘过....飘过.....飘过......飘过.......飘过........飘过........飘过....
401 - Palindromes
xjoj
09-10 303
#include #include char table[2][21]= { 'A','E','H','I','J','L','M','O','S','T','U','V','W','X','Y','Z','1','2','3','5','8', 'A','3','H','I','L','J','M','O','2','T','U','V','W','X','Y','5','1','S','E',
一个经典问题 （LCS）
yanghui07216的博客
04-19 474
一个经典问题 Problem Description 有两个字符串，比如：abedc与acbde，它们公共的序列有许多种，这个序列在原串中可以是不连续的，比如ab，ad，abe，e等都可算做他们的公共序列，但是最长的序列为abe,长度为3，那么怎么求出这个序列最长是多少呢? Input 第一行是一个整数T，代表多少组数据（T 每组数据给出两个字符串（由小写字符组成），长度都小
nyistOJ-See LCS again（二分）
信仰.的博客
03-26 483
See LCS again 时间限制：1000 ms  |  内存限制：65535 KB 难度：3 描述 There are A, B two sequences, the number of elements in the sequence is n、m; Each element in the sequence are different and less
xjoj道路
Loi_DL的博客
10-26 587
数据范围 n 题解：最长上升子序列，把a数组在b数组的位置映射到p中然后求。 #include #include #include using namespace std; int n; int dp[100233]; int a[100233],b[100233],p[100233]; int main() { scanf("%d",&
noip 模拟题,数据下载
最新发布
08-13
针对NOIP的模拟题，通常是为了帮助参赛者熟悉比赛形式和题型，提供足够的训练机会。 数据下载是NOIP比赛中的一个重要环节，因为参赛者需要根据提供的数据集进行程序开发和测试。数据下载一般通过网络进行，参赛者...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值