3-25 div3

挺久没打cf了。

A Strange Table

题意：给出一个m*n的矩阵，每一个点填入一个数字，把从左向右，从上向下递增的模式称为“by rows”的矩阵，把从上向下，从左向右的递增的模式称为“by colons”的模式，问以“by colons”模式排列的数字矩阵中x位置在“by rows”的数字矩阵中是多大

分析：
将x转化为矩阵的坐标，再通过坐标写出“by rows”相应位置的矩阵的数值
代码：

#include<bits/stdc++.h> 

using namespace std;
typedef long long ll;

 main() {
 	int t;
    ll n,m,x,row,col;
    cin>>t;
    while(t--)
    {
    cin>>n>>m>>x;
    row=(x-1)%n+1;
    col=(x-1)/n+1;
    cout<<(row-1)*m+col<<endl;
	}
}

B. Partial Replacement

题意：
给出一个以‘.’和’*‘组成的字符串，通过将’ * ‘改为‘x’使得满足：
原始字符串的第一个和最后一个‘ * ’一定要被改为‘ x ’
每个x之间的距离不大于k
题目说明原始字符串的每一个’ * ’相隔不超过k（也就是说一定是有解的）
要求最少改几个’ * '使得满足题意

分析:
我们将第一个和最后一个‘ * '改为‘ x '，但是一般情况下中间会隔着许多
所以我们要通过把’ * ‘改为’ x ‘使得他们之间连通起来，很明显，改的’ * ‘的位置是贪心的，要在能连通的情况下，选取最远的’ * ’
代码：

#include<bits/stdc++.h>
typedef long long ll;

using namespace std;

int a[55];
int main()
{
	string s;
	int t,cnt,ans,n,k,last;
	cin>>t;
	while(t--)
	{
		cnt=0,ans=2;
		cin>>n>>k;
		cin>>s;
		for(int i=0;i<s.size();++i)
		if(s[i]=='*')
		a[cnt++]=i;
		last=a[0];
		int maxnow=a[0];
		for(int i=0;i<cnt;++i)
		{
			if(a[i]-last>k)
			++ans,last=maxnow,maxnow=a[i];
			else 
			maxnow=max(maxnow,a[i]);
		}
		if(cnt==1)
		ans=1;
		cout<<ans<<endl;
	}
	
}

错误原因：
遇到a[i]-last>k的情况的时候只顾着把last设置为maxnow和++ans了，没有意识到此时maxnow也要变为a[i]，下一次循环不会再处理此时的a[i]了

C. Double-ended Strings

题意：找最长公共子串
代码：

#include<bits/stdc++.h>
typedef long long ll;

using namespace std;

int dp[25][25];
int main()
{
	int t;
	cin>>t;
	string x,y;
	int ans=0;
	while(t--)
	{
		ans=0;
		cin>>x>>y;
		for(int i=1;i<=x.size();++i)
		{
			for(int j=1;j<=y.size();++j)
			{
				if(x[i-1]==y[j-1])
				dp[i][j]=dp[i-1][j-1]+1;
				else 
				dp[i][j]=0;
				ans=max(ans,dp[i][j]);
			}
		}
		cout<<x.size()+y.size()-ans*2<<endl;
	}
	
}

D. Epic Transformation

题意：给出一个长度为n的序列，如果ai和aj的值不同，那么可以消去，问最后最少还剩几个元素

分析：通过简单分析，可以发现，每次要把最大的两个往小了减，那么就模拟，用map把每个值的次数存起来，放到优先队列里，每次取出两个最大的数减1，时间复杂度O（nlogn）。
或者进一步分析，发现要么是奇数剩一个，要么是所有小的加起来都比不上最大的，其他都会被消完（反正我是没发现）
代码：

#include<iostream>
#include<algorithm>
#include<map>
#include<vector>
#include<queue>
#include<string>
#include<string.h>
#include<stack>
typedef long long ll;

using namespace std;

//1<=1e9 1<=n<=2e5 1<=t<=1e4
int main()
{
	int t,n,x;
	cin>>t;
	while(t--)
	{
		map<int,int> mp;
		priority_queue<int> q;
		cin>>n;
	for(int i=0;i<n;++i)
	scanf("%d",&x),mp[x]++;
	for(map<int,int>::iterator it=mp.begin();it!=mp.end();it++)
	{
		q.push((*it).second);
	}
	int m1,m2;
	int ans=n;
	while(q.size()>=2)
	{
		m1=q.top();
		q.pop();
		m2=q.top();
		q.pop();
		ans-=2;
		if(m1-1)
		q.push(m1-1);
		if(m2-1)
		q.push(m2-1);
	}
	cout<<ans<<endl;
	}
	
}

E. Restoring the Permutation

题意：
说不清楚
分析：
很容易可以想到，出现增长的点必须取那个值，相等的话，最小的话就从小往大取，最大的就从该值从大往小取，然后注意取过的值不能取要调过。
用vis1和vis2分别记录最小和最大数组的出现情况，记录最小的情况下，相等从小往大取可以保证每个数字只被遍历一遍，但是相等，最大的情况下，可能会达到O（n²），当时没分析时间复杂度直接写上去结果就TLE了。我们得想一个时间复杂度更低的方法。
对于一个无序数列，我们可以使用sort后lower_Bound()的方法可以极大的减少时间复杂度，毕竟每次使用只有logn的复杂度。
因此对于相等，最大的情况，对于第i个数，我们可以每次比寻找输入数组第i个数小的数中最大的数，同时还要保证之前没有被取到，很高兴，这是一个1-n的数组没有重复，用set可以完美解决。（何大佬nb！）

#include<bits/stdc++.h> 
typedef long long ll;
using namespace std;
const int mod=1e9+7;

int a[(int)2e5+5];
int main()
{
	int t,x;
	cin>>t;
	while(t--)
	{
		int n,last=0;
		set<int> st;
		cin>>n;
		for(int i=1;i<=n;++i)
		scanf("%d",&a[i]),st.insert(i);
		for(int i=1;i<=n;++i)
		{
			if(i>1)
			printf(" ");
			if(a[i]!=a[i-1])
			printf("%d",a[i]),st.erase(a[i]);
			else 
			{
				auto p=st.begin();
				printf("%d",*p);
				st.erase(*p);
			}
		}
		printf("\n");
		for(int i=1;i<=n;++i)
		st.insert(i);
		for(int i=1;i<=n;++i)
		{
			if(i>1)
			printf(" ");
			if(a[i]!=a[i-1])
			printf("%d",a[i]),st.erase(a[i]);
			else 
			{
				auto p=st.lower_bound(a[i]);
				--p;
				printf("%d",*p);
				st.erase(*p);
			}
		}
		printf("\n");
	 } 
}