题目大意

这道题目要求将一个未加密的字符串通过特定的加密算法转换为加密后的字符串

思路

1.初始化数组 a：

根据字符串长度 n，初始化一个长度为 n 的数组 a。 设定前三个元素的值： a[0] = 1 a[1] = 2 a[2] = 4 对于 i >= 3，依次计算 a[i] = a[i-1] + a[i-2] + a[i-3]。

2.加密字符串：

遍历字符串 s 中的每个字符 s[i]： 计算加密后的字符 t[i] = s[i] + a[i]。 将结果转换为字符，并拼接到加密后的字符串 t 中。 3.输出结果：

输出加密后的字符串 t。

时间复杂度：O(n)，其中 n 是字符串的长度。需要一次遍历来计算数组 a，以及一次遍历来加密字符串。

空间复杂度：O(n)，需要存储数组 a 和加密后的字符串 t。

时间复杂度

$O(n)$

代码

C++代码

#include <iostream>
#include <string>
using namespace std;

int main() {
    string s, t = ""; // s为未加密的字符串，t为加密后的字符串
    cin >> s; // 读取未加密的字符串
    int n = s.length(); // 获取字符串的长度
    int a[n] = {0}; // 定义数组a，用于存储每个位置的偏移量，初始化为0
    
    // 遍历字符串的每个字符，计算偏移量并生成加密后的字符串
    for (int i = 0; i < n; ++i) {
        if (i == 0) {
            a[i] = 1; // a[0] = 1
        } else if (i == 1) {
            a[i] = 2; // a[1] = 2
        } else if (i == 2) {
            a[i] = 4; // a[2] = 4
        } else {
            a[i] = a[i - 1] + a[i - 2] + a[i - 3]; // a[i] = a[i-1] + a[i-2] + a[i-3]
        }
        
        // 将当前字符加上对应的偏移量后转换为新的字符，并拼接到加密后的字符串t中
        t += char(s[i] + a[i]);
    }
    
    cout << t << endl; // 输出加密后的字符串
    return 0; // 程序结束
}

python代码

def solve():
    s, t = input(), ""  # 读取未加密的字符串s，并初始化加密后的字符串t为空
    n = len(s)           # 获取字符串s的长度
    a = [0] * n          # 初始化数组a，用于存储每个位置的偏移量，初始值为0
    
    # 遍历字符串的每个字符，计算偏移量并生成加密后的字符串
    for i in range(n):
        if i == 0:
            a[i] = 1  # a[0] = 1
        elif i == 1:
            a[i] = 2  # a[1] = 2
        elif i == 2:
            a[i] = 4  # a[2] = 4
        else:
            a[i] = a[i - 1] + a[i - 2] + a[i - 3]  # a[i] = a[i-1] + a[i-2] + a[i-3]
        
        # 将当前字符的ASCII值加上对应的偏移量，转换为新的字符，并拼接到加密后的字符串t中
        t += chr(ord(s[i]) + a[i])
    
    print(t)  # 输出加密后的字符串

if __name__ == "__main__":
    solve()

Java代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        solve(); // 调用解决函数
    }

    static void solve() {
        Scanner sc = new Scanner(System.in);
        String s = sc.next(); // 读取未加密的字符串s
        String t = ""; // 初始化加密后的字符串t为空
        int n = s.length(); // 获取字符串s的长度
        int[] a = new int[n]; // 定义数组a，用于存储每个位置的偏移量，初始化为0

        // 遍历字符串的每个字符，计算偏移量并生成加密后的字符串
        for (int i = 0; i < n; ++i) {
            if (i == 0) {
                a[i] = 1; // a[0] = 1
            } else if (i == 1) {
                a[i] = 2; // a[1] = 2
            } else if (i == 2) {
                a[i] = 4; // a[2] = 4
            } else {
                a[i] = a[i - 1] + a[i - 2] + a[i - 3]; // a[i] = a[i-1] + a[i-2] + a[i-3]
            }

            // 将当前字符加上对应的偏移量后转换为新的字符，并拼接到加密后的字符串t中
            t += (char)(s.charAt(i) + a[i]);
        }

        System.out.println(t); // 输出加密后的字符串
        sc.close(); // 关闭扫描器
    }
}