程序设计思维与实践 Week15 实验

A - Q 老师的记录册

Q 老师有 N 个学生，每个学生都有各自独立的编号，且编号范围在 1 ~ N 之间。

这一天，所有学生都在不同的时间进入教室。

Q 老师记录了当编号为 i 的学生进入教室时，教室中共有 Ai 个学生（包括编号为 i 的学生）。

现要求根据这些记录，给出学生进入教室的顺序。

输入

1 ≤ N ≤ 1e5

1 ≤ Ai ≤ N，Ai 各不相同

所有数字均为整数

输出

输入格式如下：

N
A1 A2 … AN
根据学生进入教室的顺序输出学生的编号。

输入样例1

3
2 3 1

输出样例1

3 1 2

输入样例2

5
1 2 3 4 5

输出样例2

1 2 3 4 5

输入样例3

8
8 2 7 3 4 5 6 1

输出样例3

8 2 4 5 6 7 3 1

思路

这个题其实很简单，存储一下每个人的编号以及他进入教室时(包括他自己)的学生人数(这个数就是这个人进入班级的名次)，根据学生人数进行从小到大排序，输出学生编号即可。

代码

struct student
{
	int i;
	int ai;
};


student stu[100010];
bool cmp(student& a, student& b)
{
	return a.ai < b.ai;
}

int main()
{
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		stu[i].i = i + 1;
		cin >> stu[i].ai;
	}
	sort(stu, stu + n, cmp);
	for (int i = 0; i < n; i++)
	{
		cout << stu[i].i << " ";
	}
}

B - ZJM的本领

众所周知，ZJM 住在 B 站。

这一天 Q 老师来找 ZJM 玩，ZJM 决定向 Q 老师展现一下自己快速看番的本领。

ZJM 让 Q 老师任意挑选了一部番，Q老师一眼看中了《辉夜大小姐想让我告白》，已知这部番一共有 N 个精彩片段，每个精彩片段用 [L[i], R[i]] 来表示。

ZJM 从第一分钟开始看，每次可以按下快进键，快进 X 分钟，问 ZJM 最快需要多久可以看完这部番。

输入

第一行给出两个整数 N、X（1 ≤ N ≤ 50, 1 ≤ X ≤ 1e5）

接下来 N 行，每行给出两个整数，L[i]、R[i]（1 ≤ L[i] ≤ R[i] ≤ 1e5）

数据保证，R[i-1] < L[i]

输出

输出一个整数，表示 ZJM 最快看完这部番的时间。

样例输入1

2 3
5 6
10 12

样例输出1

6

样例输入2

1 1
1 100000

样例输出2

100000

NOTE
在第一个样例中，ZJM 从第 1 分钟开始看，由于 [1, 3] 区间内没有精彩片段，因此 ZJM 快进到了第 4 分钟。

观看完 [4, 6] 区间的内容后，时间来到了第 7 分钟，由于 [7, 9] 区间内没有精彩片段，因此 ZJM 快进到了第 10 分钟，观看完 [10, 12] 区间的内容后，看番结束。

一共耗时 3 + 3 = 6 分钟。

思路

精彩片段是一定要一分钟一分钟的看的，因此先计算精彩片段看的时间。

然后判断从第一分钟到第一个精彩片段开始之间的时间长度，以及每两个精彩片段之间的时间长度，如果大于x则循环快进直到时间长度不能继续快进为止，加上剩余不能快进的时间。

输出结果即可。

代码

#include
#include
using namespace std;

/*B*/
struct ttime
{
	int L;
	int R;
};
ttime tt[55];
int ans;
int n, x;
void judge(int R, int L)
{
	int temp = L - R;
	while (temp >= x)
	{
		temp -= x;
	}

	if (temp > 0)
	{
		ans += temp;
	}

}


int main()
{
	cin >> n >> x;
	ans = 0;
	for (int i = 0; i < n; i++)
	{
		cin >> tt[i].L >> tt[i].R;
		ans += tt[i].R - tt[i].L + 1;
	}
	judge(1, tt[0].L);
	for (int i = 1; i < n; i++)
	{
		judge(tt[i - 1].R + 1, tt[i].L);
	}
	cout << ans << endl;
}

C - TT 的神秘任务 - X

TT 的神秘任务系列。

这一次，TT 得到了一个长度为 N 的字符串，任务要求在原字符串中至多删去一个字符，使得字符串的字典序尽可能小。

字符串字典序的比较优先级如下：

从左往右第一个不同字符的 ASCII 值的大小关系

字符串长度

Input

第一行给出 N（2 ≤ N ≤ 2e5）。

第二行给出一个长度为 N，且仅包含小写字母的字符串。

Output

输出字典序最小的字符串。

样例输入1

3
aaa

样例输出1

aa

样例输入2

5
abcda

样例输出2

abca

思路

遍历字符串，找到第一个大于它后面那个字符的位置，输出时不输出该字符即可。
如果没有，那么不输出最后一个字符。

代码

#include
#include
using namespace std;

/*C*/
int n;
char str[200010];

int main()
{
	int flag = -1;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> str[i];
	}
	for (int i = 0; i < n - 1; i++)
	{
		if (str[i] > str[i + 1])
		{
			flag = i;
			break;
		}
	}

	if (flag == -1)
	{
		flag = n - 1;
	}
	
	for (int i = 0; i < n; i++)
	{
		if (i != flag)
		{
			cout << str[i];
		}
	}
	cout << endl;
}

D - 瑞瑞爱上字符串

瑞瑞最近迷上了字符串，因此决定出一个字符串的题。

给定两个正整数 N、K，考虑所有由 N - 2 个 a 和 2 个 b 组成的字符串，要求输出其中字典序第 K 小的。

例如当 N = 5 时，共有如下 10 种组成方式：

1. aaabb
2. aabab
3. aabba
4. abaab
5. ababa
6. abbaa
7. baaab
8. baaba
9. babaa
10. bbaaa

Input

多组数据，第一行给定 T，表示数据组数。（1 ≤ T ≤ 1e4）

对于每组数据，给出两个正整数 N、K。（3 ≤ N ≤ 1e5, 1 ≤ K ≤ min(2e9, N * (N-1) / 2 )）

N 的总和不会超过 1e5。

Output

对于每组数据，输出长度为 N 的字典序第 K 小的字符串。

Example Input

7
5 1
5 2
5 8
5 10
3 1
3 2
20 100

Example Output

aaabb
aabab
baaba
bbaaa
abb
bab
aaaaabaaaaabaaaaaaaa

思路

寻找规律。
第一个永远是a在前b在后的字符串。
之后每次，第一个b向前移动一位，第二个b可以向前一直移动到第一个b的后面一位。
拿题中所给的样例来说。
a在前b在后为1种。
第一个b移动1位的有1+1=2种。
第一个b移动2位的有1+2=3种。
第一个b移动3位的有1+3=4种。
这样得到的种数就是1+2+3+4=10种。

因此按照这个规律，计算第k种时第一个b移动了几位，在此基础上的第二个b移动的位数，然后输出该序列即可。

代码

#include
#include
using namespace std;

/*D*/
int n, k;
int main()
{
	int T;
	cin >> T;
	for (int t = 0; t < T; t++)
	{
		cin >> n >> k;
		int a = 0, b = 0;//a计算第一个b向前移动几位，b计算第二个b
		k = k - 1;


		while (1)
		{
			if (k >= 1)
			{
				k -= 1;
				a++;
				if (k >= a)
				{
					b = a;
					k -= b;
				}
				else
				{
					b = k;
					break;
				}
			}
			else
			{
				break;
			}
		}

		
		a = n - 2 - a;
		b = n - 1 - b;
		for (int i = 0; i < n; i++)
		{
			if (i == a||i == b)
			{
				cout << 'b';
			}
			else
			{
				cout << 'a';
			}
		}
		cout << endl;


	}
}

E - 苟狗之宇宙射线再打击

苟狗定义了一种新式字符串，只有掌握了这种字符串的构造方法，才可以避免宇宙射线的打击。

新式字符串定义如下：

1. 长度为偶数（可以为空）
2. 每一个奇数位置的字符都不等于它后面的那个字符
   例如，字符串 good、string、xyyx 都符合要求，而字符串 bad、aa、aabc 则不符合。

现在你获得了一个字符串 S，你需要从该字符串中删除最少的字符数，使其变成一个新式字符串，否则你就会受到宇宙射线的打击，众所周知宇宙射线是降智射线。

那么你能够避开宇宙射线吗？

Input

一个行给定一个整数 N（1 <= N <= 200000），表示字符串 S 的长度。

第二行给定长度为 N 且仅包含小写字母的字符串 S。

Output

第一行输出一个数 K（0 <= K <= N），表示需要从 S 中删除的最少的字符数量。

第二行输出删除后的字符串 S。如果为空，你可以输出一个空字符串或者什么都不输出。

Example Input1

4
good

Example Output1

0
good

Example Input2

4
aabc

Example Output2

2
ab

Example Input3

3
aaa

Example Output3

3

思路

倒序遍历字符串并用t记录删除的字符的个数，如果第i个跟第i-1个字符相同，则t++，i向=i - 1，将第i位置为空。
如果不相同，则i=i - 2.
这样遍历一遍之后，能够解决奇数位与它后面一位相同的问题。
进而判断删除后的字符串是否还是偶数长度，如果不是，删除第一个字符即可。

代码

#include
#include
#include
#include
#include 
#include 
using namespace std;
char a[200010];
int main()
{
	int n;
	cin >> n;
	cin >> a;
	int t = 0;
	int i = n - 1;
	int j = 0;
	while (i > 0)
	{
		if (a[i] == a[i - 1])
		{
			t++;
			a[i] = '0';
			i--;
		}
		else
		{
			i -= 2;
		}
	}
	if ((n - t) % 2 != 0)
	{
		a[0] = '0';
		cout << t + 1 << endl;
	}
	else
	{
		cout << t << endl;
	}
	for (i = 0; i < n; i++)
	{
		if (a[i] != '0') cout << a[i];
	}
	cout << endl;
	return 0;
}

F - 东东：“来不及解释了，快上车！！”

东东要上学了！

东东要去他家路口的公交车站等车！！！

东东从家出发，需要 d 分钟到达公交站台。

已知有 n 班公交车，第 i 路公交车在 a_i 分钟到达公交站台，随后每 b_i 分钟会有该路公交车。

东东想着他要迟到了！！！可恶！！！要迟到了！！于是他看见了一辆公交车来了，立马跳上了这辆"他见到的"第一辆公交车。

东东上车后发现了一个问题！！这不是去幼儿园的车！！！！可惜车门已经焊死。

那么问题来了东东上的是第几路车？

Input

第一行输入路线数n和东东到达的时间d(1≤n≤100,1≤d≤1e5)

接下来n行，每行两个数字a_i和b_i（1≤a_i,b_i≤1e5），分别为该路公交首辆车到达的时间和两辆车之间的发车间隔

如果有多种可能，输出一种

Output

东东所上车的公交车的路线编号。

Example Input1

2 2
6 4
9 5

Example Output1

1

Example Input2

5 5
3 3
2 5
5 6
4 9
6 1

Example Output2

3

Example Input3

3 7
2 2
2 3
2 4

Example Output3

1

思路

利用一个结构体来存储公交车的编号i，以及它第一辆到达的时间a_i、两辆车的间隔时间b_i以及东东到达车站后它来的时间arrive。
起初每辆车的arrive设为初始值a_i.
根据a_i，将公交车升序排序。
遍历公交车数组bu，如果bu[i].a_i<东东到达公交站的时间，那么更新bu[i].arrive+= bu[i].b_i * (ceil((double)(d - bu[i].a_i) / (double)bu[i].b_i));
一旦有公交车的bu[i].a_i>=东东到达公交站的时间，退出循环。
根据arrive，对公交车进行升序排序，输出第一个公交车的编号即可。

代码

#include
#include
#include
using namespace std;

/*F*/
struct bus
{
	int i;
	int a_i;
	int b_i;
	int arrive;

	bus()
	{
		arrive = 0;
	}
};

bus bu[110];
int n;
int d;
bool cmp1(bus& a, bus& b)
{
	return a.a_i < b.a_i;
}

bool cmp(bus& a, bus& b)
{
	return a.arrive < b.arrive;
}

int main()
{
	cin >> n >> d;
	for (int i = 0; i < n; i++)
	{
		bu[i].i = i + 1;
		cin >> bu[i].a_i >> bu[i].b_i;
		bu[i].arrive = bu[i].a_i;
	}

	int flag = -1;
	sort(bu, bu + n, cmp1);
	for (int i = 0; i < n; i++)
	{
		if (bu[i].a_i < d)
		{
			int temp = d - bu[i].a_i;
			bu[i].arrive += bu[i].b_i * (ceil((double)temp / (double)bu[i].b_i));
		}
		else
		{
			break;
		}
	}
	sort(bu, bu + n, cmp);
	for (int i = 0; i < n; i++)
	{
		if (bu[i].arrive >= d)
		{
			cout << bu[i].i << endl;
			break;
		}
	}

}