笔试强训week6

day1

Q1   难度⭐⭐

小红的口罩_牛客小白月赛41 (nowcoder.com)

题目：
疫情来了，小红网购了 n 个口罩。
众所周知，戴口罩是很不舒服的。小红每个口罩戴一天的初始不舒适度为 ai​。
小红有时候会将口罩重复使用（注：这是非常不卫生的！），每次重复使用时，该口罩的不舒适度会翻倍！
小红想知道，自己在不舒适度总和不超过 k 的情况下，最多能用现有的口罩度过多少天？

输入描述：第一行输入两个正整数 n 和k ，分别代表口罩的总数、以及小红最多能忍受的不舒适度
                  总和。 第二行输入 n 个正整数 ai，用空格隔开。分别代表每个口罩初始的不舒适度。

输出描述：一个整数，代表小红最多能度过的天数。

思路：

小根堆，每次用k减堆顶元素，将堆顶弹出并插入2倍堆顶

#include <vector>
#include <iostream>
#include <queue>
using namespace std;

int main()
{
    int n, k, x;
    cin >> n >> k;
    priority_queue<int, vector<int>, greater<int> > a;
    while(n --)
    {
        cin >> x;
        if(x > k)
            continue;
        else
            a.push(x);
    }
    int ans = 0;
    while(k > 0)
    {
        int z = a.top();
        k -= z;
        a.pop();
        a.push(z * 2);
        ans ++;
    }
    cout << ans - 1 << endl;
    return 0;
}

Q2   难度⭐⭐⭐

春游 (nowcoder.com)

题目：
盼望着，盼望着，东风来了，春天脚步近了
值此大好春光，老师组织了同学们出去划船，划船项目收费如下:
双人船最多坐两人，也可以坐一人，收费a元
三人船最多坐三人，也可以坐两人或者一人，收费b元
本次出游加上带队老师共n人，如何安排能使得花费最小呢?

输入描述：第一行给出一个正整数 T(1<T<1000)，代表测试数据的组数。
                  接下来 T 行每行给出三个正整数n,a,b，含义如题。

输出描述：每组输入输出一行，代表最小的花费

思路：

先判断a和b的人均消费哪个低，将a或b安排满人并将剩下的人分类安排

#include <iostream>
using namespace std;

int main()
{
    int T;
    cin >> T;
    while(T --)
    {
        long long n, a, b;
        cin >> n >> a >> b;
        if(n <= 2)
        {
            if(a > b) cout << b << endl;
            else cout << a << endl;
            continue;
        }
        long long ans = 0;
        if(a / 2 < b / 3)
        {
            ans += (n / 2) * a;
            n %= 2;
            if(n)
                ans += min(a, b - a);
        }
        else
        {
            ans += (n / 3) * b;
            n %= 3;
            if(n == 1) 
                ans += min(min(a, b), 2 * a - b);
            else if (n == 2)
                ans += min(a, b);
        }
        cout << ans << endl;
    }
    return 0;
}

Q3   难度⭐⭐⭐

数位染色_牛客题霸_牛客网 (nowcoder.com)

题目：
小红拿到了一个正整数 𝑥 。她可以将其中一些数位染成红色。然后她想让所有染红的数位数字之和等于没染色的数位数字之和。
她不知道能不能达成目标。你能告诉她吗？

输入描述：一个正整数 𝑥
输出描述：如果小红能按要求完成染色，输出"Yes"。否则输出"No"。

思路：

定义k为每一位是否染色的所有情况，分别遍历数组判断有没有可能按要求完成染色

#include <iostream>
using namespace std;

bool fun(string num)
{
    int sum = 0;
    for(char c : num)
        sum += c - '0';
    int n = num.size();
    for(int k = 0; k < (1 << n); k ++)
    {
        int yes_sum = 0;
        for(int i = 0; i < n; i ++)
            if(k & (1 << i))
                yes_sum += num[i] - '0';
        int no_sum = sum - yes_sum;
        if(yes_sum == no_sum)
            return true;
    }
    return false;
}

int main()
{
    string s;
    cin >> s;
    if(fun(s))
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
    return 0;
}

day2

Q1   难度⭐⭐

素数回文_牛客题霸_牛客网 (nowcoder.com)

题目：
现在给出一个素数，这个素数满足两点：
1、  只由1-9组成，并且每个数只出现一次，如13,23,1289。
2、  位数从高到低为递减或递增，如2459，87631。
请你判断一下，这个素数的回文数是否为素数（13的回文数是131,127的回文数是12721）。

输入描述：输入只有1行。第1行输入一个整数t，保证t为素数。

输出描述：输出一行字符串，如果t的回文数仍是素数，则输出“prime”，否则输出"noprime"。

思路：

 生成回文，判断素数

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

bool isPrime(long long n)
{   
    for(long long i = 2; i <= n / i; i ++)
        if(n % i == 0)
            return false;
    return true;
}

int main()
{
    string s;
    cin >> s;

    for(int i = s.size() - 2; i >= 0; i --)
        s += s[i];
    long long ss = stoll(s);

    if(isPrime(ss))
        cout << "prime" << endl;
    else
        cout << "noprime" << endl;
    
    return 0;
}

Q2   难度⭐⭐⭐

活动安排_牛客题霸_牛客网 (nowcoder.com)

题目：
给定𝑛n个活动，每个活动安排的时间为[𝑎𝑖,𝑏𝑖)。求最多可以选择多少个活动，满足选择的活动时间两两之间没有重合。

输入描述：第一行输入一个整数𝑛，表示可选活动个数。
                  接下来的𝑛行，每行输入两个整数𝑎𝑖,𝑏𝑖，表示第𝑖个活动的时间。

输出描述：输出一行一个整数，表示最多可选择的活动数。

思路：

先排序，再遍历判断同时安排的最多的活动数

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

bool compare(vector<int>& a, vector<int>& b) 
{
    return a[1] < b[1];
}

int maxActivities(vector<vector<int> >& a) 
{
    if (a.empty())
        return 0;

    sort(a.begin(), a.end(), compare);

    int k = 1;
    int prevEnd = a[0][1];

    for (int i = 1; i < a.size(); i ++)
        if (a[i][0] >= prevEnd) 
        {
            k ++;
            prevEnd = a[i][1];
        }

    return k;
}

int main() 
{
    int n;
    cin >> n;

    vector<vector<int>> a(n, vector<int>(2));
    for (int i = 0; i < n; i ++)
        cin >> a[i][0] >> a[i][1];

    int ans = maxActivities(a);
    cout << ans << endl;

    return 0;
}

Q3   难度⭐⭐⭐⭐⭐

合唱团_牛客题霸_牛客网 (nowcoder.com)

题目：
有 n 个学生站成一排，每个学生有一个能力值，牛牛想从这 n 个学生中按照顺序选取 k 名学生，要求相邻两个学生的位置编号的差不超过 d，使得这 k 个学生的能力值的乘积最大，你能返回最大的乘积吗？

输入描述：每个输入包含 1 个测试用例。每个测试数据的第一行包含一个整数 n (1 <= n <= 50)，表示学生的个数，接下来的一行，包含 n 个整数，按顺序表示每个学生的能力值 ai（-50 <= ai <= 50）。接下来的一行包含两个整数，k 和 d (1 <= k <= 10, 1 <= d <= 50)。

输出描述：输出一行表示最大的乘积。

思路：

二维动态规划：
dp_max[i][j]表示选取前i个学生，最后一个学生的位置为j时的最大乘积；
dp_min[i][j]表示选取前i个学生，最后一个学生的位置为j时的最小乘积。

状态转移方程为：

dp_max[i][j] = max(dp_max[i][j], max(dp_max[i-1][j-l]*a[j], dp_min[i-1][j-l]*a[j]))

dp_min[i][j] = min(dp_min[i][j], min(dp_max[i-1][j-l]*a[j], dp_min[i-1][j-l]*a[j]))

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() 
{
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i ++)
        cin >> a[i];
    int k, d;
    cin >> k >> d;
    
    vector<vector<long long>> dp_max(k, vector<long long>(n));
    vector<vector<long long>> dp_min(k, vector<long long>(n));
    
    for (int i = 0; i < n; i ++)
        dp_max[0][i] = dp_min[0][i] = a[i];
    
    long long ans = 0;
    
    for (int i = 1; i < k; i ++)
        for (int j = 0; j < n; j ++)
            for (int l = 1; l <= d; l ++)
                if (j - l >= 0) 
                {
                    dp_max[i][j] = max(dp_max[i][j], max(dp_max[i-1][j-l]*a[j], dp_min[i-1][j-l]*a[j]));
                    dp_min[i][j] = min(dp_min[i][j], min(dp_max[i-1][j-l]*a[j], dp_min[i-1][j-l]*a[j]));
                }

    for (int i = k - 1; i < n; i ++)
        ans = max(ans, dp_max[k-1][i]);
    
    cout << ans << endl;
    
    return 0;
}

day3

Q1   难度⭐⭐

跳台阶扩展问题__牛客网 (nowcoder.com)

题目：
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶(n为正整数)总共有多少种跳法。

数据范围：1≤𝑛≤20

输入描述：本题输入仅一行，即一个整数 n 

输出描述：输出跳上 n 级台阶的跳法

思路：

状态转移方程：dp[i] = dp[i] + dp[j]

#include <iostream>
using namespace std;

int dp[21] = {1, 1, 2};

int main()
{
    int n;
    cin >> n;

    for(int i = 3; i <= n; i ++)
        for(int j = 0; j < i; j ++)
            dp[i] = dp[i] + dp[j];

    cout << dp[n];
    return 0;
}

Q2   难度⭐⭐⭐

包含不超过两种字符的最长子串__牛客网 (nowcoder.com)

题目：
给定一个长度为 n 的字符串，找出最多包含两种字符的最长子串 t ，返回这个最长的长度。

输入描述：仅一行，输入一个仅包含小写英文字母的字符串

输出描述：输出最长子串的长度

思路：

unordered_map存，双指针遍历计算

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

int main()
{
    string s;
    cin >> s;

    int n = s.size();
    if(n <= 2)
    {
        cout << n << endl;
        return 0;
    }

    unordered_map<char, int> m;
    int l = 0, r = 0, len = 0;
    int cnt = 0;

    while(r < n)
    {
        if(m[s[r]] == 0)
            cnt ++;
        m[s[r ++]] ++;
        while(cnt > 2)
        {
            m[s[l]] --;
            if(m[s[l ++]] == 0)
                cnt --;
        }
        len = max(len, r - l);
    }
    
    cout << len << endl;
    return 0;
}

Q3   难度⭐⭐⭐⭐

字符串的排列_牛客题霸_牛客网 (nowcoder.com)

题目：
输入一个长度为 n 字符串，打印出该字符串中字符的所有排列，你可以以任意顺序返回这个字符串数组。

例如输入字符串ABC,则输出由字符A,B,C所能排列出来的所有字符串ABC,ACB,BAC,BCA,CBA和CAB。

输入描述：输入一个字符串,长度不超过10,字符只包括大小写字母。

思路：

DFS交换字母顺序的结果，记得用set去重

class Solution 
{
public:
    void dfs(string& s, int start, vector<string>& result) 
    {
        if (start == s.size()) 
        {
            result.push_back(s);
            return;
        }

        set<char> charSet;
        for (int i = start; i < s.size(); ++i) 
        {
            if (charSet.find(s[i]) != charSet.end()) 
                continue;
            charSet.insert(s[i]);

            swap(s[start], s[i]);
            dfs(s, start + 1, result);
            swap(s[start], s[i]);
        }
    }

    vector<string> Permutation(string str) 
    {
        vector<string> result;
        dfs(str, 0, result);
        return result;
    }
};

day4

Q1   难度⭐

[NOIP2008]ISBN号码 (nowcoder.com)

题目：
每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔之后的五位数字代表该书在出版社的编号；最后一位为识别码。
识别码的计算方法如下：
首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，…，9，再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。
你的任务是编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出你认为是正确的ISBN号码。

输入描述：只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。

输出描述：共一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。

思路：

输入->求和->比对

#include <iostream>
using namespace std;

int main()
{
    char ISBN[14];
    int sum = 0, k = 1;
    cin >> ISBN;
    for(int i = 0; i < 12; i ++)
        if(ISBN[i] >= '0' && ISBN[i] <= '9')
        {
            sum += (ISBN[i] - '0') * k;
            k ++;
        }
    sum %= 11;
    char ans = '0';
    if(sum == 10)
        ans = 'X';
    else
        ans = sum + '0';
    if(ISBN[12] == ans)
        cout << "Right";
    else
    {
        ISBN[12] = ans;
        cout << ISBN << endl;
    }
    return 0;
}

Q2   难度⭐⭐⭐⭐⭐

kotori和迷宫 (nowcoder.com)

题目：
kotori在一个n*m迷宫里，迷宫的最外层被岩浆淹没，无法涉足，迷宫内有k个出口。kotori只能上下左右四个方向移动。她想知道有多少出口是她能到达的，最近的出口离她有多远？

输入描述：第一行为两个整数n和m，代表迷宫的行和列数 (1≤n,m≤30)
                  后面紧跟着n行长度为m的字符串来描述迷宫。'k'代表kotori开始的位置，'.'代表道
                  路，'*'代表墙壁，'e'代表出口。保证输入合法。

输出描述：若有出口可以抵达，则输出2个整数，
                  第一个代表kotori可选择的出口的数量，
                  第二个代表kotori到最近的出口的步数。（注意，kotori到达出口一定会离开迷宫）
                  若没有出口可以抵达，则输出-1。

思路：

BFS 遍历时更新最短距离

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;

const int N = 110;

const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};

int n, m, sx, sy;
int dis[N][N];
char str[N][N];

void bfs() 
{
    queue<pair<int, int> > Q;
    memset(dis, 0x3f3f3f3f, sizeof(dis));
    dis[sx][sy] = 0;
    Q.push(make_pair(sx, sy));
    while (! Q.empty()) {
        int x = Q.front().first;
        int y = Q.front().second;
        Q.pop();
        for (int i = 0; i < 4; i++)  
        {
            int xx = x + dx[i];
            int yy = y + dy[i];
            if (0 <= xx && xx < n && 0 <= yy && yy < m && str[xx][yy] != '*' && dis[xx][yy] > 1e8) 
            {
                dis[xx][yy] = dis[x][y] + 1;
				if (str[xx][yy] != 'e')
					Q.push(make_pair(xx, yy));
            }
        }
    }
    int a1 = 0, a2 = 0x3f3f3f3f;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (str[i][j] == 'e' && dis[i][j] < 1e8) 
            {
                a1++;
                a2 = min(a2, dis[i][j]);
            }
    if (a1 == 0) puts("-1");
    else printf("%d %d\n", a1, a2);
}

int main() 
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) 
    {
        scanf("%s", str[i]);
        for (int j = 0; j < m; j++)
            if (str[i][j] == 'k')
                sx = i, sy = j;
    }
    bfs();
    return 0;
}

Q3   难度⭐⭐⭐⭐

矩阵最长递增路径_牛客题霸_牛客网 (nowcoder.com)

题目：
给定一个 n 行 m 列矩阵 matrix ，矩阵内所有数均为非负整数。 你需要在矩阵中找到一条最长路径，使这条路径上的元素是递增的。并输出这条最长路径的长度。

这个路径必须满足以下条件：
1. 对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外。
2. 你不能走重复的单元格。即每个格子最多只能走一次。

思路：

DFS 遍历时更新最长路径

class Solution 
{
private:
    int dx[4]={0,0,1,-1};
    int dy[4]={1,-1,0,0};
    vector<vector<int>> memo;
    int n,m;
public:
    int dfs(vector<vector<int> >& matrix, int i, int j)
    {
        if(memo[i][j] != 0)
            return memo[i][j];
        int ans = 1;
        int num = matrix[i][j];
        for(int k = 0; k < 4; k ++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && y >= 0 && x < m && y < n && num < matrix[x][y])
                ans = max(ans, 1 + dfs(matrix, x, y));
        }
        memo[i][j] = ans;
        return ans;
    }
    int solve(vector<vector<int> >& matrix) 
    {
        m = matrix.size();
        n = matrix[0].size();
        memo.resize(m, vector<int>(n));
        int ans = 1;
        for(int i = 0; i < m; i ++)
            for(int j = 0; j < n; j ++)
                ans = max(ans, dfs(matrix, i, j));
        return ans;
    }
};

day5

Q1   难度⭐⭐⭐

奇数位丢弃_牛客题霸_牛客网 (nowcoder.com)

题目：
对于一个由 0...n 的所有数按升序组成的序列，我们要进行一些筛选，每次我们丢弃去当前所有数字中第奇数位个的数。重复这一过程直到最后剩下一个数。请求出最后剩下的数字。

数据范围： 1≤𝑛≤1000，本题有多组输入

输入描述：每组数据一行一个数字，为题目中的n(n小于等于1000)。

输出描述：一行输出最后剩下的数字。

思路：

数学公式

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

int main() 
{
    int n;
	while(cin >> n)
	{
		int m = log(n + 1) / log(2);
		cout << ((1 << m) - 1) << endl;	
	}
	return 0;
}

Q2   难度⭐⭐⭐

求和_好未来笔试题_牛客网 (nowcoder.com)

题目：
输入两个整数 n 和 m，从数列1，2，3.......n 中随意取几个数,使其和等于 m ,要求将其中所有的可能组合列出来

输入描述：每个测试输入包含2个整数,n和m

输出描述：按每个组合的字典序排列输出,每行输出一种组合

思路：

DFS

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

vector<int> a;
vector<vector<int>> ans;

void dfs(int n, int m, int start) 
{
    if (m == 0) 
    {
        ans.push_back(a);
        return;
    }

    for (int i = start; i <= n; ++i) 
    {
        if (i > m) break;

        a.push_back(i);
        dfs(n, m - i, i + 1);
        a.pop_back();
    }
}

int main() 
{
    int n, m;
    cin >> n >> m;

    dfs(n, m, 1);

    for (const auto& x : ans) 
    {
        for (int num : x)
            cout << num << " ";
        cout << endl;
    }

    return 0;
}

Q3   难度⭐⭐⭐⭐

计算字符串的编辑距离_牛客题霸_牛客网 (nowcoder.com)

题目：
Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家 Levenshtein 提出的，故又叫 Levenshtein Distance 。
例如：
字符串A: abcdefg
字符串B: abcdef
通过增加或是删掉字符 ”g” 的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。
要求：给定任意两个字符串，写出一个算法计算它们的编辑距离。

数据范围：给定的字符串长度满足 1≤𝑙𝑒𝑛(𝑠𝑡𝑟)≤1000

输入描述：每组用例一共2行，为输入的两个字符串

输出描述：每组用例输出一行，代表字符串的距离

思路：

DP
状态转移方程为：dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])

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

int levenshteinDistance(const string &s1, const string &s2) 
{
    int m = s1.size();
    int n = s2.size();

    vector<vector<int>> dp(m+1, vector<int>(n+1, 0));

    for(int i = 0; i <= m; i ++) dp[i][0] = i;
    for(int j = 0; j <= n; j ++) dp[0][j] = j;

    for(int i = 1; i <= m; i ++) 
        for(int j = 1; j <= n; j ++) 
        {
            if(s1[i - 1] == s2[j - 1]) 
                dp[i][j] = dp[i - 1][j - 1];
            else 
                dp[i][j] = 1 + min({dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]});
        }

    return dp[m][n];
}

int main() 
{
    string s1, s2;
    cin >> s1 >> s2;
    
    int distance = levenshteinDistance(s1, s2);
    
    cout << distance << endl;
    return 0;
}

day6

Q1   难度⭐⭐

提取不重复的整数_牛客题霸_牛客网 (nowcoder.com)

题目：
输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
保证输入的整数最后一位不是 0 。

输入描述：输入一个int型整数
输出描述：按照从右向左的阅读顺序，返回一个不含重复数字的新的整数

思路：

倒序遍历并用unorder_set存答案

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

int main()
{
    string str;
    cin >> str;

    unordered_set<char> set;

    for(auto i = str.rbegin(); i != str.rend(); i ++)
    {
        if(set.count(*i))
            continue;
        set.insert(*i);
        cout<<*i;
    }
    
    return 0;
}

Q2   难度⭐⭐⭐

【模板】哈夫曼编码 (nowcoder.com)

题目：
给出一个有n种字符组成的字符串，其中第i种字符出现的次数为ai​。请你对该字符串应用哈夫曼编码，使得该字符串的长度尽可能短，求编码后的字符串的最短长度。

输入描述：第一行输入一个整数n，表示字符种数。
                  第二行输入n个整数ai，表示每种字符的出现次数。

输出描述：输出一行一个整数，表示编码后字符串的最短长度。

思路：

构造哈夫曼树并计算每次结合的两节点的和

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

typedef long long LL;

int main()
{
    int n;
    cin >> n;
    priority_queue<LL, vector<LL>, greater<LL> > h;
    while(n --)
    {
        LL x;
        cin >> x;
        h.push(x);
    }
    
    LL ans = 0;
    while(h.size() > 1)
    {
        LL a = h.top(); h.pop();
        LL b = h.top(); h.pop();
        h.push(a + b);
        ans += a + b;
    }
    cout << ans << endl;
    return 0;
}

Q3   难度⭐⭐⭐⭐

abb_牛客题霸_牛客网 (nowcoder.com)

题目：
leafee 最近爱上了 abb 型语句，比如“叠词词”、“恶心心”
leafee 拿到了一个只含有小写字母的字符串，她想知道有多少个 "abb" 型的子序列？
定义： abb 型字符串满足以下条件：

1. 字符串长度为 3 。
2. 字符串后两位相同。
3. 字符串前两位不同。

输入描述：第一行一个正整数 𝑛

                  第二行一个长度为 𝑛 的字符串（只包含小写字母）

输出描述："abb" 型的子序列个数。

思路：

动态规划 + 哈希表

#include <iostream>
using namespace std;

typedef long long LL;
const int N = 1e5 + 10;

int n;
char s[N];
LL f[26];
LL g[26];

int main()
{
    cin >> n >> s;
    LL ans = 0;
    for(int i = 0; i < n; i ++)
    {
        int x = s[i] - 'a';
        ans += f[x];

        f[x] = f[x] + i - g[x];
        g[x] = g[x] + 1;
    }
    cout << ans << endl;
    return 0;
}