g0901_1000.s0967_numbers_with_same_consecutive_differences.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0901_1000.s0967_numbers_with_same_consecutive_differences;

// #Medium #Breadth_First_Search #Backtracking
// #2022_03_31_Time_1_ms_(100.00%)_Space_43.2_MB_(35.45%)

import java.util.ArrayList;
import java.util.List;

/**
 * 967 - Numbers With Same Consecutive Differences\.
 *
 * Medium
 *
 * Return all **non-negative** integers of length `n` such that the absolute difference between every two consecutive digits is `k`.
 *
 * Note that **every** number in the answer **must not** have leading zeros. For example, `01` has one leading zero and is invalid.
 *
 * You may return the answer in **any order**.
 *
 * **Example 1:**
 *
 * **Input:** n = 3, k = 7
 *
 * **Output:** [181,292,707,818,929]
 *
 * **Explanation:** Note that 070 is not a valid number, because it has leading zeroes.
 *
 * **Example 2:**
 *
 * **Input:** n = 2, k = 1
 *
 * **Output:** [10,12,21,23,32,34,43,45,54,56,65,67,76,78,87,89,98]
 *
 * **Constraints:**
 *
 * *   `2 <= n <= 9`
 * *   `0 <= k <= 9`
**/
public class Solution {
    public int[] numsSameConsecDiff(int n, int k) {
        k = Math.abs(k);
        List list = new ArrayList<>();
        dfs(list, 100000, 0, n, k);
        int[] res = new int[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        return res;
    }

    private void dfs(List list, int can, int len, int n, int k) {
        if (len == n) {
            list.add(can);
            return;
        }
        if (can == 0) {
            return;
        }
        if (len == 0) {
            for (int i = 0; i <= 9; i++) {
                dfs(list, i, 1, n, k);
            }
        } else {
            int last = can % 10;
            int a = last + k;
            int b = last - k;
            if (b >= 0) {
                dfs(list, can * 10 + b, len + 1, n, k);
            }
            if (k != 0 && a < 10) {
                dfs(list, can * 10 + a, len + 1, n, k);
            }
        }
    }
}