2023-12-13：用go語言，密碼是一串長度為n的小寫字母，一則關于密碼的線索紙條，

首先將字母a到z編號為0到25編號，

紙條上共有n個整數ai，其中a1表示密碼里第一個字母的編號，

若i>1的話就表示第i個字母和第i-1個字母編號的差值，

例如，a2就代表密碼中第1個字母和第2個字母編號的差值，

若密碼是acb，那么紙條上的數字就是[5, 2, 1]，

a b c d e f

0 1 2 3 4 5

返回可能的密碼的個數，由于結果可能很大，

輸出對1000000007取模的結果。

1 <= n <= 10^5，

0 <= ai <= 25。

來自字節。

答案2023-12-13：

靈捷3.5

大體過程如下：

算法一（ways1）：

1.定義函數ways1，傳入一個整數數組arr作為參數。

2.在process1函數中，傳入當前索引i和前一個字母的編號pre作為參數。

3.如果pre小于0或大于25，則返回0；否則，進入下一步。

4.若當前索引i等于數組長度，則說明已經遍歷完所有字母，返回1。

5.否則，定義變量ans初始化為0。

6.遞歸調用process1函數，傳入i+1和pre-arr[i]作為參數，并將結果累加到ans上。

7.遞歸調用process1函數，傳入i+1和pre+arr[i]作為參數，并將結果累加到ans上。

8.返回ans作為結果。

算法二（ways2）：

1.定義函數ways2，傳入一個整數數組arr作為參數。

2.初始化變量mod為1000000007和n為數組長度。

3.創建二維切片dp，大小為(n+1)×26，用于存儲動態規劃的結果。其中dp[i][j]表示考慮第i個位置時，以j號字母結尾的可能密碼的個數。

4.將最后一行dp[n][j]全部初始化為1，表示在最后一個位置時，每個字母都是合法的密碼結尾位置。

5.倒序遍歷數組arr中的元素：

5.1.對于每個字母對應的編號j，遍歷0到25：

5.1.1.如果j-arr[i]大于等于0，則將dp[i][j]的值更新為dp[i+1][j-arr[i]]。

5.1.2.如果j+arr[i]小于26，則將dp[i][j]的值與dp[i+1][j+arr[i]]相加，并對mod取模。

6.返回dp[1][arr[0]]作為結果。

算法一的時間復雜度是O(2^n)，空間復雜度是O(n)。

算法二的時間復雜度是O(n)，空間復雜度是O(n)。

go完整代碼如下：

package main

import "fmt"

func ways1(arr []int) int {
	return process1(arr, 1, arr[0])
}

func process1(arr []int, i, pre int) int {
	if pre < 0 || pre > 25 {
		return 0
	} else {
		if i == len(arr) {
			return 1
		} else {
			ans := 0
			ans += process1(arr, i+1, pre-arr[i])
			ans += process1(arr, i+1, pre+arr[i])

			return ans
		}
	}
}

func ways2(arr []int) int {
	mod := 1000000007
	n := len(arr)
	dp := make([][]int, n+1)
	for i := 0; i <= n; i++ {
		dp[i] = make([]int, 26)
	}

	for j := 0; j < 26; j++ {
		dp[n][j] = 1
	}

	for i := n - 1; i >= 1; i-- {
		for j := 0; j < 26; j++ {
			if j-arr[i] >= 0 {
				dp[i][j] = dp[i+1][j-arr[i]]
			}
			if j+arr[i] < 26 {
				dp[i][j] = (dp[i][j] + dp[i+1][j+arr[i]]) % mod
			}
		}
	}

	return dp[1][arr[0]]
}

func main() {
	arr := []int{5, 2, 1}
	result1 := ways1(arr)
	result2 := ways2(arr)

	fmt.Println("Result using ways1:", result1)
	fmt.Println("Result using ways2:", result2)
}

c++完整代碼如下：

#include <iostream>
#include <vector>

int process1(std::vector<int>& arr, int i, int pre) {
    if (pre < 0 || pre > 25) {
        return 0;
    }
    else {
        if (i == arr.size()) {
            return 1;
        }
        else {
            int ans = 0;
            ans += process1(arr, i + 1, pre - arr[i]);
            ans += process1(arr, i + 1, pre + arr[i]);

            return ans;
        }
    }
}

int ways1(std::vector<int>& arr) {
    return process1(arr, 1, arr[0]);
}

int ways2(std::vector<int>& arr) {
    const int MOD = 1000000007;
    int n = arr.size();
    std::vector<std::vector<int>> dp(n + 1, std::vector<int>(26));

    for (int j = 0; j < 26; ++j) {
        dp[n][j] = 1;
    }

    for (int i = n - 1; i >= 1; --i) {
        for (int j = 0; j < 26; ++j) {
            if (j - arr[i] >= 0) {
                dp[i][j] = dp[i + 1][j - arr[i]];
            }
            if (j + arr[i] < 26) {
                dp[i][j] = (dp[i][j] + dp[i + 1][j + arr[i]]) % MOD;
            }
        }
    }

    return dp[1][arr[0]];
}

int main() {
    std::vector<int> arr{ 5, 2, 1 };
    int result1 = ways1(arr);
    int result2 = ways2(arr);

    std::cout << "Result using ways1: " << result1 << std::endl;
    std::cout << "Result using ways2: " << result2 << std::endl;

    return 0;
}

c完整代碼如下：

#include <stdio.h>
#include <stdlib.h>

int process1(int* arr, int i, int pre, int len) {
    if (pre < 0 || pre > 25) {
        return 0;
    }
    else {
        if (i == len) {
            return 1;
        }
        else {
            int ans = 0;
            ans += process1(arr, i + 1, pre - arr[i], len);
            ans += process1(arr, i + 1, pre + arr[i], len);

            return ans;
        }
    }
}

int ways1(int* arr, int len) {
    return process1(arr, 1, arr[0], len);
}

int ways2(int* arr, int len) {
    const int MOD = 1000000007;
    int n = len;
    int** dp = (int**)malloc((n + 1) * sizeof(int*));

    for (int i = 0; i <= n; ++i) {
        dp[i] = (int*)malloc(26 * sizeof(int));
    }

    for (int j = 0; j < 26; ++j) {
        dp[n][j] = 1;
    }

    for (int i = n - 1; i >= 1; --i) {
        for (int j = 0; j < 26; ++j) {
            if (j - arr[i] >= 0) {
                dp[i][j] = dp[i + 1][j - arr[i]];
            }
            if (j + arr[i] < 26) {
                dp[i][j] = (dp[i][j] + dp[i + 1][j + arr[i]]) % MOD;
            }
        }
    }

    int result = dp[1][arr[0]];

    for (int i = 0; i <= n; ++i) {
        free(dp[i]);
    }

    free(dp);

    return result;
}

int main() {
    int arr[] = { 5, 2, 1 };
    int len = sizeof(arr) / sizeof(arr[0]);

    int result1 = ways1(arr, len);
    int result2 = ways2(arr, len);

    printf("Result using ways1: %d\n", result1);
    printf("Result using ways2: %d\n", result2);

    return 0;
}

總結

以上是生活随笔為你收集整理的2023-12-13：用go语言，密码是一串长度为n的小写字母，一则关于密码的线索纸条， 首先将字母a到z编号为0到25编号， 纸条上共有n个整数ai，其中a1表示密码里第一个字母的编号， 若i＞1的的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。