A.Casimir’s String Solitaire

题意：给定一个只包含’A’,‘B’,'C’的字符串，判断’A’的数量加’C’的数量是否等于’B’的数量。
用count（）直接数就可以。

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n;
    cin>>n;
    while(n--)
    {
        string s;
        cin>>s;
        int x=count(s.begin(),s.end(),'A');
        int y=count(s.begin(),s.end(),'B');
        int z=count(s.begin(),s.end(),'C');
        if(x+z==y)cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}

B.Shifting Sort

题意：给定n个数（顺序任意）和一个排序规则（找一个左边界l，右边界r，个数d——代表将这个区间内前d个数移到最后），判断能否使用这种规则用n次以内的次数将这组数按递增排序。
有多种思路：
1、i从第二个数开始，找i之前的比i大的数，找到，就运用一次排序规则。因为i是从2开始的，所以每次排完序i之前的都是递增的。

#include <bits/stdc++.h>
using namespace std;
vector<int> js,ks;
int main(){
	int t; cin>>t;
	for(int i=0;i<t;i++){
		int n,c=0; int a[51]; cin>>n;
		for(int j=1;j<=n;j++)
			cin>>a[j];
		for(int j=2;j<=n;j++){
			int s=0;
			for(int k=j-1;k>=1;k--){
				if(a[j]>=a[k])
					s++;//这里直接加，因为前面已经是递增的了
			}
			if(s==j-1)
				continue;
			else{
				c++;
				ks.push_back(s+1);
				js.push_back(j);
			}
		}
		cout<<c<<endl;
		for(int i=0;i<js.size();i++){
			cout<<ks[i]<<" "<<js[i]<<" "<<js[i]-ks[i]<<"\n";
		}
		c=0;
		js.clear(); ks.clear();
		
	}
}

2、找最大的，最大的往后放。新建一个递增数组，从尾往前遍历，在原数组中找与这个递增数组的第i个数相等的数，记录这个位置，将原数组中这个位置的数放到最后。

#include<bits/stdc++.h>
using namespace std;
int T,n,a[10000],k,o1[10000],o2[10000],b[10000];
signed main()
{
    for(cin>>T;T;T--)
    {
    	cin>>n,k=0;
    	for(int i=1;i<=n;i++)
    		cin>>a[i],b[i]=a[i];
    	sort(b+1,b+n+1);
    	for(int i=n;i>0;i--)
    		for(int j=1;j<i;j++)
    			if(a[j]==b[i])
    			{
    				for(int k=j;k<i;k++)a[k]=a[k+1];
    				a[i]=b[i],o1[k]=j,o2[k]=i,k++;
    				break;
				}
    	cout<<k<<endl;
    	for(int i=0;i<k;i++)cout<<o1[i]<<" "<<o2[i]<<" 1\n";
	}
    return 0;
}

C.Ticks

题意，给出一个由 * 和 . 组成的矩阵，判断是否所有的 * 都用来组成字母V了。
思路：模拟
从头开始遍历，每找到一个 * ，就让它作为V的最底端的 * ，然后往左上和右上搜索，看是否能组成V，每查找完一个位置，如果这个位置是 * ，就将这个位置标记为1（其余为0）。将整个矩阵遍历完一遍之后，看看是否所有的 * 所处的位置都被标记成了1。

#include <bits/stdc++.h>

using namespace std;
char a[20][20];
int f[20][20];//将找到的每个*进行标记，最后看是否全部标记
void solve()
{
    memset(f, 0, sizeof f);
    int n, m, k;//k代表形成v的大小必须大于等于k
    cin >> n >> m >> k;
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= m; ++j)
        {
            cin >> a[i][j];
        }
    }
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= m; ++j)
        {
            if (a[i][j] == '*')//每找到一个*，就将他作为v的根
            {
                for (int d = k; d <= n; ++d)
                {
                    int flag = 0;
                    if (i - d < 1 || j - d < 1 || j + d > m)//判断这里的*是否成立
                    {
                        break;
                    }
                    for (int kk = 1; kk <= d; ++kk)
                    {
                        if (a[i - kk][j - kk] != '*')
                        {
                            flag = 1;
                            break;
                        }
                    }
                    if (flag)
                        continue;
                    for (int kk = 1; kk <= d; ++kk)
                    {
                        if (a[i - kk][j + kk] != '*')
                        {
                            flag = 1;
                            break;
                        }
                    }
                    if (!flag)
                    {
                        f[i][j] = 1;
                        for (int kk = 1; kk <= d; ++kk)
                        {
                            f[i - kk][j - kk] = 1;
                        }
                        for (int kk = 1; kk <= d; ++kk)
                        {
                            f[i - kk][j + kk] = 1;
                        }
                    }
                }
            }
        }
    }
    int flag = 0;
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= m; ++j)
        {
            if (a[i][j] == '*' && f[i][j] == 0)
            {
                flag = 1;
                cout << "NO\n";
                break;
            }
        }
        if (flag)
            break;
    }
    if (!flag)
        cout << "YES\n";
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        solve();
    }
    return 0;
}

E1.Permutation Minimization by Deque

题意：给定一组数，将这组数往一个队列里按顺序放，当将第一个数放进去之后，剩下的数只能放到这个队列的最前面或最后面，求出这组数能形成的最小字典序。——deque

#include <bits/stdc++.h>

using namespace std;
char a[20][20];
int f[20][20];//将找到的每个*进行标记，最后看是否全部标记
deque<int>dq;

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        dq.clear();
        int n,m;
        cin>>n;
        cin>>m;
        dq.push_back(m);
        for(int a=1;a<n;a++)
        {
            cin>>m;
            if(dq.front()>m)dq.push_front(m);
            else
                dq.push_back(m);
        }
        while(!dq.empty())
        {
            cout<<dq.front()<<" ";
            dq.pop_front();
        }
        cout<<endl;
    }
    return 0;
}