OpenJudge-1.6.07:有趣的跳跃

一、题目链接

http://noi.openjudge.cn/ch0106/07/

二、解题思路(Java)

◎ n个元素两两相邻做差的绝对值，可以得到n-1个非负整数，如果这n-1个非负整数使得[1,n-1]范围内的每个数出现且仅出现一次，则存在有
趣的跳跃，否则不存在有趣的跳跃；
◎ 方法public boolean isJolly(int[] nums)处理所有业务逻辑：
	→ 参数nums为int类型的数组，存储指定的序列；
	→ isJolly方法返回逻辑值，为true当且仅当nums中存在有趣的跳跃，否则false；
◎ 定义int类型的整数n，代表序列长度，令n = nums.length；
◎ 定义int类型的数组occur[n]，标记[1,n-1]范围内每个数出现的次数，定义后occur数组所有元素均为0，也即[1,n-1]范围内的每个数均未
出现；
◎ 定义两个int类型的整数i、t，分别代表循环变量、暂存变量；
◎ 从nums[0]到nums[n - 2]，利用循环i处理如下：
	→ 首先，令t = Math.abs(nums[i + 1] - nums[i])，也即计算当前两个相邻元素差值的绝对值；
	→ 其次：
		*** 如果t在1~n-1之间：
			··· 则令occur[t]++，代表这个值出现了一次；
			··· 如果occur[t]大于1，说明这个值出现了至少两次，则nums肯定不存在有趣的跳跃，返回false；
		*** 否则，代表t不在1~n-1之间，则nums肯定不存在有趣的跳跃，返回false；
◎ 以上均没有返回false，说明nums存在有趣的跳跃，返回true；
◎ 在main方法中调用isJolly方法，注入相应的参数后即可获得计算结果，根据计算结果为true或false，输出不同的内容。

三、解题思路(C++)

◎ n个元素两两相邻做差的绝对值，可以得到n-1个非负整数，如果这n-1个非负整数使得[1,n-1]范围内的每个数出现且仅出现一次，则存在有
趣的跳跃，否则不存在有趣的跳跃；
◎ 定义并输入int类型的整数n，代表序列长度；
◎ 定义两个int类型的数组nums[n]、occur[n]，分别存储指定的序列、标记1~n-1的值出现的次数；
◎ 定义bool类型的逻辑量flag，标记nums是否存在有趣的跳跃，令flag = true，也即初始时假设存在；
◎ 定义两个int类型的整数i、t，分别代表循环变量、暂存变量；
◎ 利用循环i输入nums数组的所有元素；
◎ 利用循环i将occur[1]~occur[n-1]置为0，也即[1,n-1]范围内的每个数均未出现；
◎ 从nums[0]到nums[n - 2]为止，利用循环i处理如下：
	→ 首先，令t = Math.abs(nums[i + 1] - nums[i])，也即计算当前两个相邻元素差值的绝对值；
	→ 其次：
		*** 如果t在1~n-1之间：
			··· 则令occur[t]++，代表这个值出现了一次；
			··· 如果occur[t]大于1，说明这个值出现了至少两次，则nums肯定不存在有趣的跳跃，令flag = false，退出循环i；
		*** 否则，代表t不在1~n-1之间，则nums肯定不存在有趣的跳跃，令flag = false，退出循环i；
◎ 循环i结束后，如果flag为true，输出Jolly，否则输出Not jolly。

四、Java程序

import java.util.Scanner;

public class Main {
    /**
     * 返回指定的序列是否存在有趣的跳跃
     *
     * @param nums int类型的数组，存储指定的序列
     * @return 逻辑值，为true当且仅当nums中存在有趣的跳跃，否则false
     */
    public boolean isJolly(int[] nums) {
        int n = nums.length; // 序列长度
        int[] occur = new int[n]; // 标记1~n-1的值出现的次数，初始时均为0
        int i;
        int t; // 暂存nums两两元素差值的绝对值
        /* 依次计算nums两两元素差值的绝对值 */
        for (i = 0; i < n - 1; i++) {
            t = Math.abs(nums[i + 1] - nums[i]); // 当前两两元素的差值的绝对值
            if (1 <= t && t <= n - 1) { // 如果t在1~n-1之间
                occur[t]++; // 代表这个值出现了一次
                if (occur[t] > 1) { // 如果该值出现了至少两次
                    return false; // 则nums肯定不存在有趣的跳跃
                }
            }
            else { // 否则，当前两两元素的差值的绝对值t不在1~n-1之间
                return false; // 则nums肯定不存在有趣的跳跃
            }
        }
        return true; // 以上均没有返回false，说明nums存在有趣的跳跃
    }

    public static void main(String[] args) {
        Main test = new Main();
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = input.nextInt();
        }
        System.out.print(test.isJolly(nums) ? "Jolly" : "Not jolly");
    }
}

五、C++程序

#include <iostream>
using namespace std;

int main()
{
    int n; // 序列长度
    cin >> n;
    int nums[n]; // 存储指定的序列
    int occur[n]; // 标记1~n-1的值出现的次数
    bool flag = true; // 标记nums是否存在有趣的跳跃，初始时假设存在
    int i;
    int t;
    /* 输入nums数组的所有元素 */
    for (i = 0; i < n; i++)
    {
        cin >> nums[i];
    }
    /* 标记1~n-1的值均未出现 */
    for (i = 1; i <= n - 1; i++)
    {
        occur[i] = 0;
    }
    /* 依次计算nums两两元素差值的绝对值 */
    for (i = 0; i < n - 1; i++)
    {
        t = abs(nums[i + 1] - nums[i]); // 当前两两元素差值的绝对值
        if (1 <= t && t <= n - 1) // 如果t在1~n-1之间
        {
            occur[t]++; // 代表这个值出现了一次
            if (occur[t] > 1) // 如果该值出现了至少两次
            {
                flag = false; // 则nums肯定不存在有趣的跳跃
                break; // 无需继续检测，跳出循环i
            }
        }
        else // 否则t不在1~n-1之间
        {
            flag = false; // 则nums肯定不存在有趣的跳跃
            break; // 无需继续检测，跳出循环i
        }
    }
    if (flag) // 如果nums存在有趣的跳跃
    {
        cout << "Jolly";
    }
    else // 否则nums不存在有趣的跳跃
    {
        cout << "Not jolly";
    }
    return 0;
}