题目：D
题意：从一个字符串s中删除一些字符或者不删，构成t字符串，保证t[i]的价值等于b[i]，t[i]的价值计算就是t字符串中所有的位置如果t[j]>t[i]，那么t[i]的价值就加上abs(i-j)。保证一定有答案。
首先可以考虑到，b[i]的最小值0肯定是t中最大的字符，未产生任何贡献，往后的字符产生的贡献都是一定需要比他大的字符，考虑到数据很小直接暴力。但是同一个字符可能产生多次不然放置不成功，或者这个字符不能放置多次我不能放他，本质其实就是放置最大的个数是多少，次大的是多少，以此类推，最后转化为字符即可。
（代码比较丑）
#include<cmath>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<istream>
#include<vector>
#include<stack>
#include<set>
#include<map>
#include<algorithm>
#include<queue>
#define inf 0x3f3f3f3f
#define llinf 0x3f3f3f3f3f3f3f3f
#define MAX_len 200005*4
using namespace std;
typedef long long ll;
typedef pair<int,int> PP;
const int mod=998244353;
const int MAXlen=1e5+10;
long double eps=1e-9;
char s[55];
int b[110];
int book[30];
int c[110];
bool vis[60];
char ans[60];
int book1[60];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
memset(book,0,sizeof(book));
memset(book1,0,sizeof(book1));
scanf("%s",s);
int n,i,j;
n=strlen(s);
int m;
scanf("%d",&m);
for(i=1;i<=m;i++)
{
scanf("%d",&b[i]);
c[i]=b[i];
}
for(i=0;i<n;i++)
{
book[s[i]-'a']++;
}
memset(vis,false,sizeof(vis));
sort(c+1,c+1+m);
int hh=c[1];
memset(c,0,sizeof(c));
int cnt=0;
int tempdj=1;
for(i=1;i<=m;i++)
{
if(vis[i])
continue;
if(b[i]==hh)
{
for(j=25;j>=0;j--)
{
if(book[j])
{
vis[i]=true;
cnt++;
book1[i]=tempdj;
c[tempdj]++;
break;
}
}
}
}
tempdj++;
while(cnt<m)
{
for(i=1;i<=m;i++)
{
if(vis[i])
continue;
int sum=0;
for(j=1;j<=m;j++)
{
if(!vis[j]||j==i)
continue;
if(book1[j]<tempdj)
{
sum+=abs(j-i);
}
}
if(sum==b[i])
{
vis[i]=true;
cnt++;
book1[i]=tempdj;
c[tempdj]++;
break;
}
sum=0;
tempdj++;
for(j=1;j<=m;j++)
{
if(!vis[j]||j==i)
continue;
if(book1[j]<tempdj)
{
sum+=abs(j-i);
}
}
if(sum==b[i])
{
vis[i]=true;
cnt++;
book1[i]=tempdj;
c[tempdj]++;
break;
}
tempdj--;
}
}
int k=25;
for(i=1;i<=m;i++)
{
while(book[k]<c[i])
{
k--;
}
for(j=1;j<=m;j++)
{
if(book1[j]==i)
{
ans[j]='a'+k;
}
}
k--;
}
for(i=1;i<=m;i++)
printf("%c",ans[i]);
printf("\n");
}
return 0;
}
题目：E
题意：给定n个元素，组成一条项链，顺时针转完k之后不变，问最大长度。
数据范围不大，可以暴力。先分析，k不变的话，那么当len%k!=0的时候全部一样才行。len%k=0的时候，要保证每个相同的字符串有n/k个并且数量大于k则成立，当k%len=0的时候，则直接是len。
将k拆分，直接枚举len。
#include<cmath>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<istream>
#include<vector>
#include<stack>
#include<set>
#include<map>
#include<algorithm>
#include<queue>
#define inf 0x3f3f3f3f
#define llinf 0x3f3f3f3f3f3f3f3f
#define MAX_len 200005*4
using namespace std;
typedef long long ll;
typedef pair<int,int> PP;
const int mod=998244353;
const int MAXlen=1e5+10;
long double eps=1e-9;
char s[2020];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
vector<int>hh;
int book[30]={0};
int n,k,i,j;
scanf("%d %d",&n,&k);
scanf("%s",s);
for(i=1;i*i<=k;i++)
{
if(k%i==0)
{
hh.push_back(i);
hh.push_back(k/i);
}
}
int MAX=0;
for(i=0;i<n;i++)
{
book[s[i]-'a']++;
MAX=max(MAX,book[s[i]-'a']);
}
//for(i=0;i<26;i++)
{
// printf("%d ",book[i]);
}
// return 0;
for(i=1;i<=n;i++)
{
for(j=0;j<hh.size();j++)
{
int sum=0;
if(i%hh[j]==0)
{
int temp=i/hh[j];
for(int u=0;u<26;u++)
{
if(book[u]>=temp)
{
sum+=book[u]/temp;
}
}
if(sum>=hh[j])
{
MAX=max(MAX,i);
}
}
if(hh[j]%i==0)
{
MAX=max(i,MAX);
}
}
}
printf("%d\n",MAX);
}
return 0;
}
题目:F1
题意：n长度的数据，每次可以操作，将a[i]置于数组最前或者最后，问最小次数使得a非递减。
分析数据，已经自己有序的子序列我们可以不管，只需要去解决乱序的，其实也就是找最长的连续的子序列。数据不大并且保证每个数据都不相同，暴力。证明的话就是贪心策略，这里的连续表示已经排好序的数据连在一起的，先做一个离散化。
#include<cmath>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<istream>
#include<vector>
#include<stack>
#include<set>
#include<map>
#include<algorithm>
#include<queue>
#define inf 0x3f3f3f3f
#define llinf 0x3f3f3f3f3f3f3f3f
#define MAX_len 200005*4
using namespace std;
typedef long long ll;
typedef pair<int,int> PP;
const int mod=998244353;
const int MAXlen=1e5+10;
long double eps=1e-9;
int a[3020],c[3020];
int dp[3020];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
int n,i,j;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
c[i]=a[i];
}
sort(c,c+n);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(a[j]==c[i])
{
a[j]=i;
break;
}
}
}
for(i=0;i<n;i++)
{
dp[i]=1;
for(j=0;j<i;j++)
{
if(a[i]-a[j]==1)
{
dp[i]=max(dp[i],dp[j]+1);
}
}
}
int MAX=1;
for(i=0;i<n;i++)
MAX=max(MAX,dp[i]);
printf("%d\n",n-MAX);
}
return 0;
}
F2
比F1的数据范围更大，并且存在了相同的数。
思路来源：click
离散化。
本质上0就是开头，2就是结尾的意思。
dp[i][0]:全是a[i]，以a[i]结尾的序列。
dp[i][1]:a[i]还没有放完继续接，或者接a[i]-1开头，或者把a[i]-1全部接走。
dp[i][2]:接走全部的a[i]，并且最后一个a[i]结束。
#include<cmath>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<istream>
#include<vector>
#include<stack>
#include<set>
#include<map>
#include<algorithm>
#include<queue>
#define inf 0x3f3f3f3f
#define llinf 0x3f3f3f3f3f3f3f3f
#define MAX_len 200005*4
using namespace std;
typedef long long ll;
typedef pair<int,int> PP;
const int mod=998244353;
const int MAXlen=1e5+10;
long double eps=1e-9;
int a[200100],c[200100];
int pos[200100];
int dp[200100][3];// 0表示取相同的数以a[i]为结尾 1表示a[i]没取完 2表示a[i]全部取完以其结尾的最大长度
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
map<int,int>hh,cnt;
map<int,PP>h;
int n,i,j;
int len=0;
scanf("%d",&n);
int MAX=1;
pos[0]=0;
for(i=0;i<=n;i++)
{
dp[i][0]=dp[i][1]=dp[i][2]=0;
pos[i]=0;
}
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
if(!hh[a[i]])
{
c[++len]=a[i];
hh[a[i]]=1;
}
}
hh.clear();
sort(c+1,c+len+1);
for(i=1;i<=n;i++)
{
a[i]=lower_bound(c+1,c+len+1,a[i])-c;
}
for(i=1;i<=n;i++)
{
cnt[a[i]]++;
MAX=max(cnt[a[i]],MAX);
if(!hh[a[i]])
{
hh[a[i]]=1;
h[a[i]].first=i;
h[a[i]].second=i;
pos[a[i]]=i;
}
else
{
h[a[i]].second=i;
}
}
for(i=1;i<=n;i++)
{
dp[i][0]=dp[pos[a[i]]][0]+1;
dp[i][1]=max(dp[pos[a[i]]][1]+1,max(dp[pos[a[i]-1]][0]+1,dp[pos[a[i]-1]][2]+1));
if(i==h[a[i]].second)
{
dp[i][2]=dp[h[a[i]].first][1]+cnt[a[i]]-1;
}
pos[a[i]]=i;
for(j=0;j<3;j++)
{
MAX=max(MAX,dp[i][j]);
}
}
printf("%d\n",n-MAX);
}
return 0;
}