【洛谷】P1152 欢乐的跳（详细易懂思路）

题目描述

一个 n 个元素的整数数组，如果数组两个连续元素之间差的绝对值包括了 [1,n−1] 之间的所有整数，则称之符合“欢乐的跳”，如数组 {1,4,2,3} 符合“欢乐的跳”，因为差的绝对值分别为：3,2,1。

给定一个数组，你的任务是判断该数组是否符合“欢乐的跳”。

输入格式

每组测试数据第一行以一个整数 n(1≤n≤1000) 开始，接下来 n 个空格隔开的在 [−108,108] 之间的整数。

输出格式

对于每组测试数据，输出一行若该数组符合“欢乐的跳”则输出 Jolly，否则输出 Not jolly。

输入输出样例

输入 #1

4 1 4 2 3

输出 #1

Jolly

输入 #2

5 1 4 2 -1 6

输出 #2

Not jolly

说明/提示

1≤n≤1000

---

---

#include <iostream>
#include <cmath>
using namespace std;
int main()
{
	int n, i, j, t, A[1000] = { 0 }, B[1000] = { 0 }, C[1000] = { 0 };
	cin >> n;
	for (i = 0; i < n - 1; i++)
		C[i] = i + 1;
	for (i = 0; i < n; i++)
		cin >> A[i];
	for (i = 0; i < n - 1; i++)
		B[i] = abs(A[i] - A[i + 1]);
	for (i = 0; i < n - 1; i++)		//冒泡排序，共进行n-1轮比较
	{
		for (j = 0; j < n - 1 - i; j++)		//在每轮中要进行(n-1-i)次两两比较
		{
			if (A[j] > A[j + 1])		//如果前面的数大于后面的数
			{
				t = A[j];		//用t存储原来A[j]的值
				A[j] = A[j + 1];		//将A[j+1]的值赋给A[j]
				A[j + 1] = t;		//将原本A[j]的值赋给A[i+1],实现"对换"
			}
		}
	}
	for (i = 0; i < n - 2; i++)
	{
		for (j = 0; j < n - 2 - i; j++)
		{
			if (B[j] > B[j + 1])
			{
				t = B[j];
				B[j] = B[j + 1];
				B[j + 1] = t;
			}
		}
	}
	for (i = 0; i < n - 1; i++)
	{
		if (B[i] != C[i])
			break;
	}
	if (B[i] == C[i])
		cout << "Jolly";
	else
		cout << "Not jolly";
	return  0;
}

---

1. 整体功能概述

这段 C++ 代码旨在判断输入的整数序列是否为 “Jolly Jumper” 序列。其大致流程是先读取序列的长度 n 以及序列中的各个整数存入数组 A，接着通过计算数组 A 相邻元素差值的绝对值得到数组 B，同时生成一个预期的数组 C（由 1 到 n - 1 的连续整数构成），最后通过比较数组 B 和数组 C 的元素来确定输入序列是否符合 “Jolly Jumper” 序列的条件。

2. 代码详细分析

变量声明与初始化

int n, i, j, t, A[1000] = { 0 }, B[1000] = { 0 }, C[1000] = { 0 };

声明了一系列整型变量：

• n：用于存储输入整数序列的长度。
• i、j：主要作为循环的计数器。
• t：用于在交换数组元素时暂存元素的值。

同时声明了三个整型数组 A、B、C，并将它们的所有元素初始化为 0。其中，数组 A 用来存储输入的整数序列，数组 B 用于存储数组 A 相邻元素差值的绝对值，数组 C 用于生成一个预期的比较序列。

读取输入数据

cin >> n;
for (i = 0; i < n; i++)
    cin >> A[i];

首先通过 cin >> n 从标准输入读取整数序列的长度 n。然后利用循环，根据读取到的长度 n，通过 cin >> A[i] 依次从标准输入读取 n 个整数，并将它们存储到数组 A 中。

生成数组 B 和 C

• 生成数组 B：

  for (i = 0; i < n - 1; i++)
      B[i] = abs(A[i] - A[i + 1]);

• 生成数组 C：

  for (i = 0; i < n - 1; i++)
      C[i] = i + 1;

  通过循环，将从 1 到 n - 1 的连续整数依次赋值给数组 C 的各个元素，以此生成一个预期的比较序列，用于后续与数组 B 进行比较。

  对数组 A 进行排序

  for (i = 0; i < n - 1; i++)
  {
      for (j = 0; j < n - 1 - i; j++)
      {
          if (A[j] > A[j + 1])
          {
              t = A[j];
              A[j] = A[j + 1];
              A[j + 1] = t;
          }
      }
  }

  这里使用冒泡排序算法对数组 A 进行排序。通过两层嵌套循环，内层循环每次比较相邻的两个元素 A[j] 和 A[j + 1]，如果 A[j] > A[j + 1]，就利用临时变量 t 进行元素交换，将较大的元素往后移动，经过多次循环，最终实现数组 A 的排序。

  对数组 B 进行排序

  for (i = 0; i < n - 2; i++)
  {
      for (j = 0; j < n - 2 - i; j++)
      {
          if (B[j] > B[j + 1])
          {
              t = B[j];
              B[j] = B[j + 1];
              B[j + 1] = t;
          }
      }
  }

  也是采用冒泡排序算法对数组 B 进行排序。通过两层嵌套循环，内层循环比较相邻的两个元素 B[j] 和 B[j + 1]，如果 B[j] > B[j + 1]，就借助临时变量 t 进行元素交换，使数组 B 的元素逐渐有序。

  判断是否为 “Jolly Jumper” 序列

  for (i = 0; i < n - 1; i++)
  {
      if (B[i]!= C[i])
          break;
  }
  if (B[i] == C[i])
      cout << "Jolly";
  else
      cout << "Not jolly";

  在前面的 for 循环中，一旦发现 B[i] 与 C[i] 不相等，就会通过 break 跳出循环。此时，i 的值已经不再是循环正常结束时应该的值，而是跳出循环时的那个值———借助这一元素，来判断是循环自然结束还是通过break跳出循环。

• 这样就能准确地判断输入的整数序列是否为 “Jolly Jumper” 序列了。