ACM实训第十天

Brainman

问题

背景
雷蒙德·巴比特把他弟弟查理逼疯了。最近，雷蒙光是看一眼就数了一下，一下子就有246根牙签洒得到处都是。他甚至会数扑克牌。查理也希望能做这样酷的事情。他想在类似的任务中打败他的兄弟。

问题
查理是这么想的。假设你得到一个N个数的序列。我们的目标是移动这些数字，以便在最后排序。唯一允许的操作是交换两个相邻的数字。让我们举个例子:
从:2 8 0 3开始
交换(2 8)8 2 0 3
Swap (20) 8 0 2 3
交换(2 3)8 0 3 2
Swap (8 0) 0 8 3 2
交换(8 3)0 3 8 2
Swap (8 2) 0 3 2 8
交换(32 2)0 2 3 8
交换(3 8)0 2 8 3
Swap (8 3) 0 2 3 8

所以数列(28 0 3)可以通过9个相邻数字的交换来排序。然而，甚至可以用三个这样的交换来排序:
从:2 8 0 3开始
Swap (8 0) 2 0 8 3
Swap (2 0) 0 2 8 3
Swap (8 3) 0 2 3 8

问题是:对给定序列排序时，相邻数的最小交换次数是多少?由于查理没有雷蒙德的智力，他决定作弊。这就是你要发挥作用的地方。他让你为他写一个计算机程序来回答这个问题。放心吧，他会为此出一大笔钱的。
输入
第一行包含场景的数量。
对于每个场景，您都会得到一行，其中首先包含序列的长度N (1 <= N <= 1000)，然后是序列的N个元素(每个元素都是[- 1000000,1000000]中的整数)。这一行中的所有数字都用一个空格隔开。
输出
以包含“场景#i:”的行开始每个场景的输出，其中i是从1开始的场景的编号。然后打印单行，其中包含对给定序列排序所需的最小相邻数字交换次数。用空行结束该场景的输出。

思路

这段代码的主要目的是计算一系列数组中的逆序对总数。逆序对指的是在一个数组中，如果前面的数字比后面的数字大，则这两个数字构成一个逆序对。

程序首先通过scanf读取测试场景的数量m，然后对于每一个场景，读取该场景中的元素数量p以及具体的元素值，存储在数组a中。之后，通过两层嵌套循环遍历数组中的每一对元素，比较它们的大小，统计逆序对的数量。最后，按照要求的格式输出每个场景的逆序对数量。

整体上，这是一个解决逆序对问题的直接暴力解法，时间复杂度为O(n^2)，其中n是数组中的元素数量。对于较大的数据集，可能需要更高效的算法（如归并排序过程中计算逆序对）来优化性能。

#include<iostream> // 引入iostream库，用于处理输入输出流
#include<stdio.h> // 引入stdio.h库，提供标准输入输出函数
using namespace std; // 使用std命名空间

const int n=200000; // 声明常量n，表示数组的最大长度
int a[n],b[n]; // 定义两个整型数组a和b，每个数组的长度为n

int main(){ // 程序的主函数
    int m; // 定义整型变量m，用于存储测试场景的数量
    scanf("%d",&m); // 读取输入的测试场景数量m

    for(int k=1; k<=m; k++){ // 遍历每一个测试场景
        int p; // 定义整型变量p，用于存储每个场景中的元素数量
        scanf("%d",&p); // 读取当前场景的元素数量p

        for(int i=1;i<=p;i++) // 遍历输入的p个整数，存入数组a
            scanf("%d",&a[i]);

        int ans=0; // 初始化计数器ans，用于记录逆序对的数量

        // 双重循环计算逆序对数量
        for(int i=1;i<=p;i++) 
            for(int j=i+1;j<=p;j++)
                if(a[i]>a[j]) // 如果a[i]大于a[j]，说明形成一个逆序对
                    ans++; // 逆序对数量加一

        // 输出结果
        printf("Scenario #%d:\n%d\n\n",k,ans); // 打印当前场景的编号和逆序对数量
    }
    return 0; // 主函数结束，返回0表示程序正常执行完毕
}

代码 

#include<iostream> 
#include<stdio.h>
using namespace std;
const int n=200000;
int a[n],b[n];
int main(){
	int m;
	scanf("%d",&m);
	for(int k=1; k<=m; k++){
		int p;
		scanf("%d",&p);
		for(int i=1;i<=p;i++)
			scanf("%d",&a[i]);
		int ans=0;
		for(int i=1;i<=p;i++)
			for(int j=i+1;j<=p;j++)
				if(a[i]>a[j])
					ans++;
		printf("Scenario #%d:\n%d\n\n",k,ans);
	}
	return 0;
}

Tokitsukaze and Good 01-String (hard version)

问题

这是这个问题的难点。两个版本之间的唯一区别是，更难的版本额外要求最小数量的子段。

Tokitsukaze有一个二进制字符串s长度为n的，仅由0和1组成，n是偶数。现在Tokitsukaze分裂为5划分为最小数量的连续子段，并且对于每个子段，每个子段中的所有位都是相同的。在那之后，如果所有子段的长度都是偶数，则认为是好的。

例如:s是“11001111”，将其分为“11”、“00”和“1111”。它们的长度是2, 24分别为偶数，所以“11001111”是好的。另一个例子是是“1110011000”，它会被分成“111”、“00”、“11”和“000”，它们的长度都是3, 2, 23． 显然，“1110011000”并不好。Tokitsukaze想制造s很好，通过改变s中某些位置的值． 具体来说，她可以执行任意次数的操作:改变si的值到'0'或'1'(1≤i≤n）. 你能告诉她最少要做多少次手术吗好吗?同时，她还想知道最小子段的个数可以在所有解中以最少的操作次数进行划分。

输入
第一个包含一个正整数t(1≤t≤10000)——测试用例的数量。

对于每个测试用例，第一行包含一个整数n(2≤n≤2*10^5) - s的长度，可以保证n是偶数。

第二行包含一个二进制字符串s长度为n的，只由0和1组成。可以保证n的和所有测试用例不超过2*10^5．

输出
对于每个测试用例，打印带有两个整数的单行——生成s的最小操作数很好，子段的最小数量是可以在所有解中以最少的操作次数进行划分。

 

思路

这段代码的目的是解决一类字符串操作问题，具体是针对一个由两种字符交替组成的字符串，计算使所有相同字符不相邻所需的最少交换次数。程序首先读取测试用例的数量，然后对于每个测试用例，读取字符串长度和字符串内容。通过遍历字符串，比较相邻字符是否相同，统计不同字符间需要交换的次数（x）和相同字符内部为了满足题目要求的最小交换次数（y）。最后输出这两者的值，其中y确保至少为1，即使整个字符串由同一种字符组成，也认为需要一次交换来满足题目条件。

#include <iostream> // 包含iostream库，用于处理输入输出流
#include <cstring> // 包含cstring库，用于字符串操作
#include <algorithm> // 包含algorithm库，用于算法操作如排序等
#include <vector> // 包含vector容器库
#include <cmath> // 包含cmath库，用于数学相关操作

using namespace std; // 使用std命名空间
typedef long long ll; // 定义ll为long long的别名，方便表示大整数

const int N = 2e5 + 10; // 常量N，表示处理数据规模的上限
int n; // 定义整型变量n，用于存储数据长度
string s; // 定义字符串s，用于存储输入的字符串

int main() // 主函数开始
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); // 关闭同步，提高IO效率
    
    int T; // 定义整型变量T，用于存储测试用例数量
    cin >> T; // 读取测试用例数量T
    
    while(T--) // 遍历每一个测试用例
    {
        cin >> n >> s; // 读取当前测试用例的长度n和字符串s
        
        int x = 0, y = 0; // 初始化计数器x和y，x记录不同字符间的交换次数，y记录相同字符内部的最小交换次数
        char last = ' '; // 初始化last变量，记录上一次遇到的字符
        
        // 遍历字符串s，步长为2检查相邻字符
        for (int i = 0; i < s.size(); i += 2)
        {
            if (s[i] != s[i+1]) // 如果相邻字符不同
                x++; // x加1，表示需要交换
            else // 如果相邻字符相同
            {
                if (last != s[i]) // 如果这个字符与上一次遇到的不同
                    y++; // y加1，因为至少需要一次交换来调整
                last = s[i]; // 更新last为当前字符
            }
        }
        
        // 根据逻辑，y至少为1，即使所有字符都相同，也需要至少一次交换使得相邻字符不同
        printf("%d %d\n", x, (y > 1) ? y : 1); // 输出x和y的值，其中y确保至少为1
    }
    
    return 0; // 主函数结束，返回0表示程序执行成功
}

代码 

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>

using namespace std;
typedef long long ll;

const int N = 2e5 + 10;
int n;
string s;

int main()
{
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	int T;
	cin >> T;
	while(T--)
	{
		cin >> n >> s;
		int x = 0, y = 0;
		char last = ' ';
		for (int i = 0; i < s.size(); i += 2)
		{
			if (s[i] != s[i+1])
				x++;
			else
			{
				if (last != s[i])
					y++;
				last = s[i];
			}
		}
		//cout << x << " " << max(1, y) << endl;
		printf("%d %d\n", x, (y > 1) ? y : 1);
	}
	return 0;
}