匹配 解题报告

最新推荐文章于 2021-01-16 21:00:13 发布
最新推荐文章于 2021-01-16 21:00:13 发布
阅读量748 收藏
点赞数
分类专栏： 特殊数据 分治 DP 文章标签： 分治 特殊数据 匹配 dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ta201314/article/details/46817077
版权
DP 同时被 3 个专栏收录
43 篇文章 1 订阅
订阅专栏
分治
12 篇文章 0 订阅
订阅专栏
特殊数据
9 篇文章 0 订阅
订阅专栏

求一棵树的最大匹配以及最大匹配方案数模m。

n≤1.5∗106,m≤109

时间限制：2s
空间限制：32MB
= =这是一道卡内存傻题，一个显然的DP方程是设f(n,0/1)为这个点向其父亲的边选或不选这个子树能得到的最大匹配，然后g(n,0/1)是其方案数，然后随便转移一下就好了。
注意到状态有4*n个，而内存太小了，最多只能开5*n的数组。。我感觉遍历一棵树似乎至少就需要3*n，所以说DP的状态必须要动态地记录。
然后我使用的沙茶方法是一种关于直径的分治，就是每次选出一条直径，然后从下向上DP，不在直径上的就递归处理，这样每一层的空间复杂度都是O(1)。显然，每一层的直径都是严格小于上一层的，直径长度大于 n√ 的显然不会超过 n√ 个，而直径长度小于 n√ 的显然也不会超过 n√ 个，所以这玩意儿的层数是 n√ 的。空间复杂度 O(n√) ，时间复杂度 O(n) ，然而妈蛋常数太大差点T掉。
但是蛋疼的地方就是初始化的时候我默认把叶子节点的g初始化为1，然后对于n=1，m=1的时候跪了。这已经是我第二次因为模的数等于1跪掉了，所以说对于m有范围的情况一定要试m=1的情况！
然而我考完以后才发现这其实只要按链剖一样按size找就可以轻易地把空间复杂度降到 O(log2n) 的。。而且不知道怎么回事改过的代码一直被卡常数，然后把当年因为怕内存爆被改成bitset的一个长度为n的布尔数组改了回来就A了。。
代码（ n√ 沙茶分治）： 

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<bitset>
using namespace std;
bitset<1500005> flag;
int succ[3000005],ptr[1500005],next[3000005],etot=1;
void in(int &x){
    char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    x=0;
    for(;c>='0'&&c<='9';c=getchar())x=x*10+(c^'0');
}
void addedge(int u,int v){
    next[etot]=ptr[u],ptr[u]=etot,succ[etot++]=v;
}

int m,n;
//next[1..n]表示i的儿子们在哪里开始的，succ[1..n]存它的儿子们,ptr[1..n]存它的父亲们。 
//next[n+1+1..n+1+n]表示其儿子们的最大深度,succ[n+1..n+n]存每个点的depth 
struct DS{
    int f[2],g[2];
};
typedef long long LL;
#define inf 1000000000
DS dfs(int node,int depth){
    int i,Maxson;
    while(next[node]!=next[node+1]){
        succ[n+node]=depth;
        Maxson=succ[next[node]];
        for(i=next[node];++i<next[node+1];)
            if(next[n+1+succ[i]]>next[n+1+Maxson])
                Maxson=succ[i];
        node=Maxson;
    }
    succ[n+node]=depth;
    DS ans,sps,Max,now;
    for(;;){
        ans=(DS){{0,1},{1%m,1%m}},Max=(DS){{inf,-inf},{1%m,1%m}};
        for(i=next[node];i<next[node+1];++i){
            if(succ[n+succ[i]])now=sps;
            else now=dfs(succ[i],depth+1);
            if(now.f[1]-now.f[0]>Max.f[1]-Max.f[0]){
                Max=now;
                Max.g[0]=(LL)ans.g[1]*now.g[1]%m;
                if(now.f[1]-now.f[0]==0)Max.g[0]=(Max.g[0]+(LL)ans.g[1]*now.g[0])%m;
            }
            else
                if(now.f[1]-now.f[0]==Max.f[1]-Max.f[0])Max.g[0]=((LL)Max.g[0]*now.g[0]+(LL)ans.g[1]*now.g[1])%m;
                else Max.g[0]=(LL)Max.g[0]*now.g[0]%m;
            ans.f[1]+=now.f[0];
            ans.g[1]=(LL)ans.g[1]*now.g[0]%m;
        }
        if(Max.f[1]-Max.f[0]>=0){
            ans.g[0]=Max.g[0];
            ans.f[0]=ans.f[1]-1+Max.f[1]-Max.f[0];
        }
        else{
            ans.g[0]=ans.g[1];
            ans.f[0]=ans.f[1]-1;
        }
        sps=ans;
        //cout<<node<<":"<<ans.f[0]<<","<<ans.f[1]<<" "<<ans.g[0]<<","<<ans.g[1]<<endl;
        if(succ[n+ptr[node]]==succ[n+node])node=ptr[node];
        else return ans;
    }
}
int main(){
    freopen("match.in","r",stdin);
    freopen("match.out","w",stdout);
    int i,u,v,j;
    in(n);
    for(i=n;--i;){
        in(u),in(v);
        addedge(u,v),addedge(v,u);
    }
    in(m);
    //dfs出父亲来。 
    int node=1,tmp;
    flag[1]=1;
    while(node){
        if(!flag[succ[ptr[node]]]){
            flag[succ[ptr[node]]]=1;
            tmp=node;
            node=succ[ptr[node]];
            ptr[tmp]=next[ptr[tmp]];
        }
        else if(next[ptr[node]])swap(succ[ptr[node]],succ[next[ptr[node]]]);
        else{
            ptr[node]=succ[ptr[node]];
            node=ptr[node];
        }
    }
    //按父亲排序 
    //next[n+2..n+n]作为新next，succ[n+1..n]作为新的表头。 
    //ptr[1..n]是父亲,next[1..n]作为分界点。 
    memset(succ,0,sizeof(succ));
    memset(next,0,sizeof(next));
    for(i=1;i<=n;++i)next[i+n]=succ[n+ptr[i]],succ[n+ptr[i]]=n+i;
    next[1]=1;
    for(i=1;i<=n;++i){
        next[i+1]=next[i];
        for(j=succ[n+i];j;j=next[j])succ[next[i+1]++]=j-n;
    }
    for(i=1;i<=n;++i)next[n+2+i]=0;
    //求最大深度 
    flag.reset();
    for(i=n;i;--i)succ[n+i]=next[i];
    node=1;
    while(node){
        if(succ[n+node]==next[node+1]){
            ++next[n+1+node];
            flag[node]=1;
            node=ptr[node]; 
        }
        else
            if(!flag[succ[succ[n+node]]])node=succ[succ[n+node]];
            else next[n+1+node]=max(next[n+1+node],next[n+1+succ[succ[n+node]++]]);
    }
    for(i=n;i;--i)succ[n+i]=0;
    //dp
    DS ans=dfs(1,1);
    printf("%d\n%d\n",ans.f[0],ans.g[0]);
}

代码（链剖）：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<iostream>
#include<bitset>
using namespace std;
bool flag[1500005];
int succ[3000005],ptr[1500005],next[3000005],etot=1;
void in(int &x){
    char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    x=0;
    for(;c>='0'&&c<='9';c=getchar())x=x*10+(c^'0');
}
void addedge(int u,int v){
    next[etot]=ptr[u],ptr[u]=etot,succ[etot++]=v;
}

int m,n;
//next[1..n]表示i的儿子们在哪里开始的，succ[1..n]存它的儿子们,ptr[1..n]存它的父亲们。 
//next[n+1+1..n+1+n]表示其儿子们的最大深度,succ[n+1..n+n]存每个点的depth 
struct DS{
    int f[2];
    long long g[2];
};
#define inf 1000000000
DS dfs(int node,int depth){
    int i,Maxson;
    while(next[node]!=next[node+1]){
        succ[n+node]=depth;
        Maxson=succ[next[node]];
        for(i=next[node];++i<next[node+1];)
            if(next[n+1+succ[i]]>next[n+1+Maxson])
                Maxson=succ[i];
        node=Maxson;
    }
    succ[n+node]=depth;
    DS ans,sps,Max,now;
    for(;;){
        ans=(DS){{0,1},{1%m,1%m}},Max=(DS){{inf,-inf},{1%m,1%m}};
        for(i=next[node];i<next[node+1];++i){
            if(succ[n+succ[i]])now=sps;
            else now=dfs(succ[i],depth+1);
            if(now.f[1]-now.f[0]>Max.f[1]-Max.f[0]){
                Max=now;
                Max.g[0]=ans.g[1]*now.g[1]%m;
                if(now.f[1]-now.f[0]==0)Max.g[0]=(Max.g[0]+ans.g[1]*now.g[0])%m;
            }
            else
                if(now.f[1]-now.f[0]==Max.f[1]-Max.f[0])Max.g[0]=(Max.g[0]*now.g[0]+ans.g[1]*now.g[1])%m;
                else Max.g[0]=Max.g[0]*now.g[0]%m;
            ans.f[1]+=now.f[0];
            ans.g[1]=ans.g[1]*now.g[0]%m;
        }
        if(Max.f[1]-Max.f[0]>=0){
            ans.g[0]=Max.g[0];
            ans.f[0]=ans.f[1]-1+Max.f[1]-Max.f[0];
        }
        else{
            ans.g[0]=ans.g[1];
            ans.f[0]=ans.f[1]-1;
        }
        sps=ans;
        //cout<<node<<":"<<ans.f[0]<<","<<ans.f[1]<<" "<<ans.g[0]<<","<<ans.g[1]<<endl;
        if(succ[n+ptr[node]]==succ[n+node])node=ptr[node];
        else return ans;
    }
}
int main(){
    freopen("match.in","r",stdin);
    freopen("match.out","w",stdout);
    int i,u,v,j;
    in(n);
    for(i=n;--i;){
        in(u),in(v);
        addedge(u,v),addedge(v,u);
    }
    in(m);
    //dfs出父亲来。 
    int node=1,tmp;
    flag[1]=1;
    //printf("%f\n",(double)clock()/CLOCKS_PER_SEC);
    while(node){
        if(!flag[succ[ptr[node]]]){
            flag[succ[ptr[node]]]=1;
            tmp=node;
            node=succ[ptr[node]];
            ptr[tmp]=next[ptr[tmp]];
        }
        else if(next[ptr[node]])swap(succ[ptr[node]],succ[next[ptr[node]]]);
        else{
            ptr[node]=succ[ptr[node]];
            node=ptr[node];
        }
    }
    //printf("%f\n",(double)clock()/CLOCKS_PER_SEC);
    //按父亲排序 
    //next[n+2..n+n]作为新next，succ[n+1..n]作为新的表头。 
    //ptr[1..n]是父亲,next[1..n]作为分界点。 
    memset(succ,0,sizeof(succ));
    memset(next,0,sizeof(next));
    for(i=1;i<=n;++i)next[i+n]=succ[n+ptr[i]],succ[n+ptr[i]]=n+i;
    next[1]=1;
    for(i=1;i<=n;++i){
        next[i+1]=next[i];
        for(j=succ[n+i];j;j=next[j])succ[next[i+1]++]=j-n;
    }
    memset(next+n+3,0,sizeof(int)*n);
    //printf("%f\n",(double)clock()/CLOCKS_PER_SEC);
    //求size 
    memset(flag,0,sizeof(flag));
    for(i=n;i;--i)succ[n+i]=next[i];
    node=1;
    while(node){
        if(succ[n+node]==next[node+1]){
            ++next[n+1+node];
            flag[node]=1;
            node=ptr[node]; 
        }
        else
            if(!flag[succ[succ[n+node]]])node=succ[succ[n+node]];
            else next[n+1+node]+=next[n+1+succ[succ[n+node]++]];
    }
    memset(succ+n+1,0,sizeof(int)*n);
    //printf("%f\n",(double)clock()/CLOCKS_PER_SEC);
    //dp
    DS ans=dfs(1,1);
    //printf("%f\n",(double)clock()/CLOCKS_PER_SEC);
    printf("%d\n%I64d\n",ans.f[0],ans.g[0]);
}

总结：
①一定要试极限数据啊！！！尤其是模的数有范围的情况！
②如果不是为了位运算还是不要用bitset的好，直接布尔数组快多了。。
③不要用什么沙茶 n√ 直径分治了，被链剖 log2n 虐爆了有木有！

TA201314
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NOIP2014提高组复赛解题报告
TA
11-18 8618
Day1 T1生活大爆炸版剪刀石头布：模拟，水； T2联合权值：树形DP，水； T3Flappy Birds： 这道题我当时算时间复杂度算错了，O(nm^2)的时间复杂度给算成O(nm)了，所以根本就没想优化，以后①算时间复杂度的时候要小心一点了。 其实正解也是很简单的，只是在直译式DP的基础上做了一点小优化。 直译式DP：设f(i,j)为到达当前点的最小步数，则 f(i,j)->f
[NOIP2014]子矩阵解题报告
TA
04-18 4848
这题看上去没啥思路，一看数据范围小的可怜，就算了下暴搜的时间复杂度O(C(16,8)∗(C(16,8)+m3))≈108O(C(16,8)*(C(16,8)+m^3))≈10^8似乎没啥问题，然后就写了个暴搜，出了点数据发现T了，又加了个剪枝然后就A了。。 结果一看人家的代码全是DP。。让我有点蛋疼。 其实只要把暴搜的后半部分一改就可以了，把二维压成一维后，就有一个显然的DP方程：处理出选一列的
洛谷P1739 表达式括号匹配解题报告
MARSHALBEN的博客
09-19 1256
洛谷1739 表达式括号匹配 本题地址： http://www.luogu.org/problem/show?pid=1739 题目描述 假设一个表达式有英文字母（小写）、运算符（+，—，*，/）和左右小（圆）括号构成，以“@”作为表达式的结束符。请编写一个程序检查表达式中的左右圆括号是否匹配，若匹配，则返回“YES”；否则返回“NO”。表达式长度小于255，左圆括号少于20个。 输入输出格
Leetcode #44. Wildcard Matching 通配符匹配 解题报告
MebiuW的专栏
04-15 3506
1 解题思想嗯，最近遇到要写Hard的频率偏高，而最近的重心也不再Leetcode上，心累。。Hard写起来都好麻烦。这道题好像之前也有几次，讲过类似的题目，也就是*能任意长度和字符匹配，？能匹配任意一个字符，现在需要验证给定的通配符是否能匹配输入的串这道题应该有很多做法，我的这个感觉只是一个比较一般的解法，这道题的测试量比较大，所以单纯的暴力搜索是AC不掉的，而我的做法，就是使用动态规划。不知道大
BZOJ3507: [Cqoi2014]通配符匹配 解题报告
L_0_Forever_LF的专栏
10-01 1602
日常吐槽部分可以跳过这题又坑了蒟蒻一下午，表示很不爽（自己弱能怪谁） 看完题想了一会一直觉得是很高级的做法，自己肯定不会了，搜了题解并不能看懂在讲什么，去问大神，Claris表示这不是 贪心+hash 就能搞定的题吗（为什么我连贪心都没想到啊还有怎么hash匹配并不会） 敲完怎么拍都拍不出错，一个小时后拍出来结果发现一个判 ？ 的地方下标没更新，改了就A了。 但是为什么我注释掉这个判 ？ 的语
解题报告 (九) 二分图最大匹配
热门推荐
英雄哪里出来
01-16 8万+
二分图最大匹配题集-全网最全
串结构练习——字符串匹配 解题报告
丙三醇
01-24 544
题目描述 给定两个字符串string1和string2，判断string2是否为string1的子串。 输入 输入包含多组数据，每组测试数据包含两行，第一行代表string1，第二行代表string2，string1和string2中保证不出现空格。 输出 对于每组输入数据，若string2是string1的子串，则输出"YES"，否则输出"NO"。 示例
LeetCode解题总结
10-09
LeetCode解题总结 1. 数组 1.1 从有序数组中删除重复元素 1.2 在排序数组被旋转后进行查找 1.3 寻找两个排序数组的中位数 1.4 最长连续序列 1.5 累加和 1.6 移除数组中指定值 1.7 下一个排列 1.8 第n个全排列 1.9 ...
栈》的解题报告.ppt
07-11
请编写一个程序检查表达式中的左右圆括号是否匹配，若匹配，则返回“YES”；否则返回“NO”。表达式长度小于255，左圆括号少于20个。 分析：假设输入的字符串存储在c中（var c:string[255]）。 我们可以定义一个栈：...
英语信息匹配题解题技巧PPT课件.pptx
10-14
英语信息匹配题解题技巧PPT课件.pptx
基于字符串模式匹配算法的病毒感染检测问题 实验四（源代码+实验报告）
05-31
《数据结构（C语言版 第2版）》严蔚敏 实验四 基于字符串模式匹配算法的病毒感染检测问题，含实验报告
lrucacheleetcode-leet-code-scala:leetcodescala解题报告
06-29
lru cache leetcode Scala Solution for Leetcode 数据结构与算法 问题归类 数据结构 链表 堆、队列、栈 二叉树 查找表 前缀树 图 算法思想 模拟和技巧 枚举，查找和搜索 贪心 ...字符串匹配 滑动窗口
calc(陈立杰) 解题报告
TA
10-08 6580
感觉最近状态真是烂到爆。。首先不妨令序列有序，然后再乘n！即可。一上来先想到可以倍增，设f[i][j]表示在1~j中选i个数，那么有j->2j，便可以通过枚举一边选了几个得到。但是算错了复杂度以为是O(n3logn)O(n^3\log n)的。。（矩阵乘习惯了一倍增就感觉是三方挂logn。。）（没想到看了题解以后这竟然就是标算。。）然后又想，既然倍增是三次方的。。。那只能看看暴力转移了。f(i,j)
[COGS193]最多因子数 解题报告
TA
12-06 4612
这真是一道很神的题，看起来似乎只能暴搜，但是暴搜的话又没法解决出现了大质数因子的问题，所以我蛋疼了一下午还是写了个骗分+暴力，但没想到竟然A了！ 后来我看了题解，感到很不满意，因为题解根本就没有处理存在大质数的问题。 让我们先来看看所谓的正解：     本题的要求是，求出一个给定区间内的含因子数最多的整数。     首先，有必要明确一下如何求一个数的因子数。若一个数N满足N=P1N1·
最优贸易解题报告
TA
11-05 1969
----------------------------最优贸易是一个n=10^5级的稀疏图，求max{0,w[j]-w[i]}(g[1][i]&&g[i][j]&&g[j][n]).---------------------------- 一、SPFA的功能与理解，不能仅仅局限于求最短路，而可以是图中某点到图中所有点的某种关系。比如说本题中可以用来求某点到1的所有路径中的Wmax。 二、DF
[NOI2010]超级钢琴 解题报告
TA
01-17 1954
超级钢琴 【问题描述】 小Z是一个小有名气的钢琴家，最近C博士送给了小Z一架超级钢琴，小Z希望能够用这架钢琴创作出世界上最美妙的音乐。 这架超级钢琴可以弹奏出n个音符，编号为1至n。第i个音符的美妙度为Ai，其中Ai可正可负。 一个“超级和弦”由若干个编号连续的音符组成，包含的音符个数不少于L且不多于R。我们定义超级和弦的美妙度为其包含的所有音符的美妙度之和。两个超级和弦被认为是相同的
[ZJOI2016]线段树 解题报告
TA
09-20 1910
。。很久以前看过题面然后没有仔细想，再做的时候忘了序列是随机的了。。然后怎么搞都是O(n4)O(n^4)的。 我们可以将状态设为f(x,i,l,r)，表示在i次操作后，[l,r]＜x，l-1和r+1大于等于x的方案数。（不妨认为a[0]=a[n+1]=∞a[0]=a[n+1]=\infty）这样的话假如说有跨越区间端点的操作，那么就一定会使操作中的数≥x。然后令g(x,j)表示让位置j最终＜x的方
[SDOI2010]地精部落解题报告
TA
11-22 1844
这道题是我看了题解以后才做出来的，真是一道神题，但是大神dbbuy
[COGS1862]种树 解题报告
TA
01-03 1733
【问题描述】 A城市有一个巨大的圆形广场，为了绿化环境和净化空气，市政府决定沿圆形广场外圈种一圈树。园林部门得到指令后，初步规划出n个种树的位置，顺时针编号1到n。并且每个位置都有一个美观度Ai，如果在这里种树就可以得到这Ai的美观度。但由于A城市土壤肥力欠佳，两棵树决不能种在相邻的位置（i号位置和i+1号位置叫相邻位置。值得注意的是1号和n号也算相邻位置！）。 最终市政府给园林部门提供了m棵
简述poj3525的解题思路
最新发布
03-13
作为一个 AI，我可以回答这个问题。...具体的解题思路是：先将字符串按照一定规则进行分割，然后对分割后的字符串进行匹配，最后统计匹配的次数即可。常用的字符串匹配算法有 KMP 算法、AC 自动机算法等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值