| ２０２０／７／２ | 要点 |
|---|---|
| 普通ｄｐ | 两个字符串的匹配，一个字符串可以添删改其中的字符，求变成另一个字符串的最少操作步数，ｄｐ［ｉ］［ｊ］表示分别到ｉ和ｊ位置的最少步数，这样状态无后效性 |
| 模拟题 | 字符串模拟，用python方便很多， ｏｒｄ和ｃｈｒ两个函数，利用 map(int,input().strip().split())输入, |
| 水题 | 字符串模拟,python:a[::-1]实现字符串reverse |
| ２０２０／７／3 | 要点 |
|---|---|
| 水题 | 对于int,ceil(n/2.0)和(n+1)/2 不一样?不一样,前者输出时doubel,后者时int,例如对于n=493796142,2.46898e+008和246898071 |
| 水题 | 看清题意即为等差数列+特判 |
| 水题 | 无 |
时间好快呀，一晃过去六天没写题
| 2020/7/9 | 要点 |
|---|---|
| 模拟题 | 利用递归或者栈做字符串解压模拟，从外到里，一层层去掉括号，可以保证顺序不变 |
| 贪心 | 开始以为是个dp，发现复杂度过不去。注意枚举顺序，利用有限队列维护。priority_queue<ll,vector<ll>,greater<ll> >是小顶堆 |
| 区间dp | 1.区间dp的特点是，区间长度较小，而且一般状态三四个维度，最外层枚举区间长度，第二层确定起点 |
| 区间dp | 求最长回文子序列，(dp[i][j]) 为字符串s 的第 i 个字符到第 j个字符的最长回文子序列长度。状态转移：(if: s[i]==s[j],dp[i][j]=dp[i+1][j-1]+2. else:dp[i][j]=max(dp[i+1][j],max[i][j-1]) |
| 区间dp | 求最长回文子串，我们可以强行规定(dp[i][j]) s中第 i 个字符和第 j 个字符都必须选，换句话说 (dp[i][j]) 其实是选完了整个 i 到 j 的区间的，也就是说，(dp[i][j]==j-i+1)时，这个区间是个回文串，否则就不是,(dp[i][j]=0) ,所以只需要用0，1表示是否是回文串。状态转移：(if :dp[i+1][j-1]==1 ,and ,s[i]==s[j]时,dp[i][j]=1,else :dp[i][j]=0)。 |
| 区间dp | 利用两个字符串，组拼成为一个字符串，只需要保持原来每个字符串的字符相对位置不变即可，与上一个类似，(dp[i][j][k][l])表示选择第一个字符串i到j的位置，第二个字符串k到l的位置，是否组成回文串，四个状态注意。 |
2020/7/14
题意：将n个石子分成k份，且每份不能为空，任意两个方案不能相同(不考虑顺序)。
把n划分为k个，那么先从n中拿一个x，题目便变为将(n-x)分为k-1种，所以我们可以依次拿一个1出来，递推式为(f[i−1][j−1])，即有1的情况；
没有1的情况，可以看成为j个元素预分配一个1，剩下的便没有1，即f[i-j][j]f[i−j][j]。故当i>ji>j时便有了递推式(f[i][j]=f[i-1][j-1]+f[i-j][j])
超时dfs,保存每一种方案
void dfs(int num,int cur,int big){
if(cur==1){
v.push_back(num);
v_copy.assign(v.begin(),v.end());
sort(v_copy.begin(),v_copy.end());
se.insert(v_copy);
v.pop_back();
return;
}
for(int i=big;i<=num-cur+1;i++){
v.push_back(i);
dfs(num-i,cur-1,big);
v.pop_back();
}
}
不超时dfs：
int dfs(int num,int cur){
if(num<cur)return 0;
if(cur==1)return 1;
return dfs(num-1,cur-1)+dfs(num-cur,cur);
}
2020/7/19
题意：判断一个串是否是另一个串的子序列。（都只包含小写字母）
题解：如果主串中有两个一样的字母，我们肯定会选前一个，因为是子序列，如果选前一个不可以，那么选后面的同一个字母肯定就更不可以了。
开一个数组(next[i][′a′...′z′])表示主串第 i个字母之后（包含第i个）的第一个′a′...′z′分别在哪一个位置，子串每次与之匹配的时候顺着往后走就行。
代码：
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
char str[N];
char s[N];
int l;
int ind[N][26];//包括i后面的位置的第一个j出现的位置
void init(){
l=strlen(str+1);
for(int j=0;j<26;j++){
int last=-1;
for(int i=l;i>=0;i--){
if(str[i]-'a'==j)last=i;
ind[i][j]=last;
}
}
}
int main(){
scanf("%s",str+1);
int n;
scanf("%d",&n);
init();
while(n--){
bool f=true;
scanf("%s",s+1);
int len=strlen(s+1);
int cur=0;
for(int i=1;i<=len;i++){
if(cur>l){
f=false;
break;
}
cur=ind[cur][s[i]-'a'];
if(cur==-1){
f=false;
break;
}
cur++;
}
if(f)puts("Yes");
else puts("No");
}
return 0;
}
题意：给你一棵 n 个节点的树（保证 n 是偶数），你需要将 n 个节点分为 n/2 个点对，使得每个点对的两个点的距离的和最小。
题解：
- 首先，在最短的距离和之中一条边一定不会被覆盖两次。
- 对于一个点x，它子树中的点一定会尽量在子树中找到匹配的点内部消化掉（要么连父亲要么连兄弟），只有根是有可能会往上找一个点来匹配（不然又会出现重复覆盖一条边的情况。
- 那么如果我们不去想点怎么两两配对而是来考虑每个边选不选——对于当前点 x，如果它的子树大小（包括它自己）有偶数个点，那么肯定在子树里面就互相连完了，它不需要向上连；如果是奇数个点，x 就需要去匹配上面的点了，所以 x 向它父亲连的边就要选。
代码：
#include<bits/stdc++.h>
#define ll long long
using namespace std;
struct edge{
int from,to,cost;
edge(int _from,int _to,int _cost){
from=_from;to=_to;cost=_cost;
}
};
const int N=1e4+10;
vector<edge>ve;
vector<int>G[N];
int tot[N];//tot[i]表示包含i点的i的子树大小
void add_edge(int u,int v,int cost){
ve.push_back(edge(u,v,cost));
G[u].push_back(ve.size()-1);
}
ll ans=0;
void dfs(int u,int fa,int len){
tot[u]=1;
for(int i=0;i<G[u].size();i++){
int id=G[u][i];
int v=ve[id].to;
if(v==fa)continue;
dfs(v,u,ve[id].cost);
tot[u]+=tot[v];
}
if(tot[u]%2==1)ans+=len;
}
int main(){
int T;
scanf("%d",&T);
while(T--){
int n;
ans=0;
scanf("%d",&n);
for(int i=0;i<n-1;i++){
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
add_edge(u, v, w);
add_edge(v, u, w);
}
dfs(1,0,0);
printf("%lld
",ans);
for(int i=0;i<=n;i++)G[i].clear();
ve.clear();
}
return 0;
}