腾讯2021笔试（后台，回忆版，2020.9.6）

Leetcode 链接
欢迎来讨论
后续将继续更新校招笔试题

T1.**(双指针)
大意：给你两个降序链表（数组），求它们的公共子序列

分析：因为题目给的是有序的序列，那么求子序列就很简单了，
定义a[],b[]两个数组,
我们只需要两个指针i，j，分别从两个数组的起点开始比较，
1.a[i]=b[j]，res+=a[i],i++,j++
2.a[i]>b[j],i++，
3.a[i]<b[j],j++
代码较简单就不贴了

T2（并查集）
大意：大团队里有m个小团队，每个团队有1个或者1个以上的成员，某个成员可能不止属于一个团队。一条消息从编号为0 的员工出发，散布到它所在的团队成员这，知晓消息的人，会将消息扩散到其所在的所有团队。

**分析：**换个方式说，0号知道消息了，告诉了他朋友（同一团队的人），他的朋友们又将消息传达给各自的朋友们，in short->朋友的朋友是朋友！！！

那就是裸的并查集了。不过据说数据有问题，比题目中描述了大了，不少了wa了（我习惯开大一些的数组。。。。）
代码:

#include <bits/stdc++.h>
using namespace std;
int fa[100005]; //并查集 保存集合的父亲节点
int n;
int fd(int x) //路径压缩
{
    if (x != fa[x])
    {
        fa[x] = fd(fa[x]);
    }
    return fa[x];
}
void un(int a, int b)
{
    a = fd(a);
    b = fd(b);
    if (a != b)
        fa[a] = b;
}
void init()
{ //初始化集合
    //cout << n << endl;
    for (int i = 0; i < n; i++)
    {
        fa[i] = i;
    }
}
/*
50 5
2 1 2
5 10 11 12 13 14
2 0 1
2 49 2
4 6 7 8 2

*/
int main()
{

    int m, x;
    cin >> n >> m;
    init();
    for (int i = 1; i <= m; i++)
    {
        int x;
        cin >> x;
        int first; //保留第一个数
        for (int j = 1; j <= x; j++)
        {
            int id;
            cin >> id; //输入员工编号
            if (j == 1)
            {
                first = id;
            }
            else
            {
                un(first, id); //将同一个团队的放在同一个集合
            }
        }
    }
    int zero = fd(0); //
    int res = 1;
    for (int i = 1; i < n; i++)
    {
        if (fd(i) == zero)
            res++; //与0在同一个集合 答案加1
    }
    cout << res << endl;
    return 0;
}

T3.（sort，hash）
大意： 给你一些字符串，统计它们出现的次数，输出出现次数为前K大和前K小的字符串以及其出现次数

分析：题意很直接了。。。map（unordered_map）统计出现次数，对pair排序即可，
pair<出现次数，字符串>

T4. (数组)
大意：给你一个数组（长度为偶数），问你分别单独的删除每一个值后，剩下部分中位数是多少

分析:删除掉一个数后，数组长度由n变为n-1.中位数只会偏移一位
所以我们只需要看删除的是是在 n/2左边 还是右边，
1.在右边，输出后的中位数还是原数组的中位数
2.在左边，输出后的中位数是原数组的中位数的右边一位

T5（逆序数，动态规划）
考虑这题好像有点难度，题解就写的比较多，希望有耐心往下看
原题链接：来自于Atcoder
补完题可以去提交

大意：由两种棋子组成的序列，如BRBRB（B，R分别代表不同的棋子），每颗棋子有一个编号，第i颗棋子的编号为id[i],希望你通过交换相邻棋子的操作，使得同种颜色的棋子组成的序列（可以不连续）是递增的！
样例：
输入：
3
BRRBRB
2 3 1 1 2 3
输出:
5

分析:整理题意 我们得到的 关键词是: 最小交换次数 数组有序
1.有经验的同学可能马上就想到了一个东西 逆序数
2.我们知道 冒泡排序的（最小）交换次数就是 逆序数的数量
3.如果这题棋子颜色全相同，那么我们直接通过 1，2 就能找到几种方法求得答案了（直接冒泡排序，归并排序，树状数组）
4.但是，并不可以QAQ ,如何通过已知知识推这题呢
考虑冒泡排序 4 3 2 1

我们每一轮将第 k（ 1<=k<=4 ） 小,通过交换移动到它最终所在的位置（第k个位置）
(1)将1归位，代价为3

（2）将2归位，代价位2

（3）将3归位，代价位1

（4）将4归位，代价位0

a[i]的归位的代价：a[i]前面 值比a[i]大的数 的数量（逆序数）。
我们可以把归位 操作， 看成 插入到一个新数组的操作，最后形成的新数组是有序的
(1)将1插入新数组，代价为3，因为 2 3 4 还未插入新数组，我们需要通过交换操作“跨”过它们，进入新数组

	新数组：1 

（2）将2插入新数组，代价位2，因为 3 4 还未插入新数组，我们需要通过交换操作“跨”过它们，进入新数组

	新数组：1 2 

（3）将3插入新数组，代价位1，同上

	新数组：1 2 3 

（4）将4插入新数组，代价位0，同上

	新数组：1 2 3 4

证明如下：
目标数列显然满足这样一个性质：对于 ∀i∈[1,N)，都有 ai<ai+1。因此如果当前数列不是目标数列，一定 ∃ i∈[1,n) 使得 ai>ai+1，那么 ai 和 ai+1 就构成了一对逆序对，我们需要一次操作交换这两个数。这样周而复始地进行交换操作，最终操作数量就是逆序对对数。

对于本题
我们考虑也用类似的“插入”法，将黑棋的前i（1<=i<=n）个和红棋的前j个（1<=j<=n）插入到一个新的数组中，使得黑棋，红旗都是有序的，并计算其代价！

那么我们考虑需要考虑这里的代价，是否和冒泡排序中的代价 相等呢？

1.考虑已经 成功插入了 i个 黑棋 j个红旗，在插入第i+1个黑棋代价是什么？
我们完全 可以借鉴 上面"插入一个新数组的做法"，那插入第i+1个黑棋代价 就是i+1个黑棋需要“跨过”的棋子的数量
2.哪些是需要跨过”的棋子，就是初始位置在第i+1个黑棋前，但又要在第 i+1个黑棋之后插入新数组的棋子

它们具体是这些情况：
（1）.初始位置在第i+1个黑棋前的 编号为i+2~n的黑棋，这个很好理解，就是冒泡排序里的标准”逆序数“了
（2）.初始位置在第i+1个黑棋前的 编号为j+1_{n的**白棋**，（因为1}j的白棋已经在新数组了，j+1之后的还没有进来。。。。）

插入第j+1个白棋的代价同理…
(1)第j+1个白棋前，还未插入新数组的白棋数量
（2）第j+1个白棋前，还未插入新数组黑棋数量

分析至此，已经差不多了，定义 dp[i][j]为插入i个黑棋，j个白棋的代价
那么dp[i][j]=min(dp[i-1][j]+costB(i,j),dp[i][j-1]+costR(i,j))
cost_B(i,j):在 第i个黑棋前 的 编号大于i的 黑棋的数量+ 第i个黑棋前 的 编号大于j的白棋数量

cost_R(i,j):在 第j个白棋前 的 编号大于j的 白棋的数量+ 第j个白棋前 的 编号大于i的黑棋数量

我们可以通过 o(n^2)预处理 ，通过 暴力+前缀和 处理得到

costB[i][j]:第i个位置前，编号小于等于j的黑棋数量
costR[i][j]:第i个位置前，编号小于等于j的白棋数量

pos为第i个白棋/黑棋的位置
cost_B(i,j)=pos- cost_B[pos][i] - cost_R[pos][j]
cost_R(i,j)=pos - cost_R[pos][i] - cost_B[pos][j]
代码：

#include <iostream>
#include <string.h>
#include <cstdlib>
#include <algorithm>
#include <map>
using namespace std;
typedef long long ll;
const int maxn = 4000 + 5;
int dp[maxn][maxn];
int costB[maxn][maxn];
int costR[maxn][maxn];
int id[maxn * 2]; //棋子的编号
int n;
string str;
map<int, int> posB, posR;
void pre_cost() //初始化costB，costR
{
    //costB[i][1~n] 在第i个棋子前面 编号为1~n黑棋子的出现次数
    //costR[i][1~n] 在第i个棋子前面 编号为1~n白棋子的出现次数
    for (int i = 0; i < 2 * n; i++)
    {
        for (int j = 0; j < i; j++)
        { //costB[i][j] 在第i个棋子前面 id为j的黑棋子个数
            int index = id[j];
            if (str[j] == 'B')
            {
                costB[i][index]++;
            }
            else
            {
                costR[i][index]++;
            }
        }
    }
    //对costB[i][1~n]，costA[i][1~n]做前缀和后
    //costB[i][j]代表，第i个棋子前面，编号<=j的黑棋子个数
    for (int i = 0; i < n * 2; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            costR[i][j] += costR[i][j - 1];

            costB[i][j] += costB[i][j - 1];
        }
    }
    
}
int cost_B(int i, int j)
{ //加入第i个黑棋，且1~j个白棋已经排好序的代价
    int Cost = 0;
    int pos = posB[i];
    //计算 pos 位置前，值大于i的黑棋，值大于j的白棋的数量
    Cost = pos - costB[pos][i] - costR[pos][j];
    return Cost;
}
int cost_R(int i, int j)
{ //加入第i个白棋，且1~j个白棋已经排好序的代价
    int Cost = 0;
    int pos = posR[i];
    //计算 pos 位置前，值大于i的白棋，值大于j的黑棋的数量
    Cost = pos - costR[pos][i] - costB[pos][j];
    return Cost;
}

void init()
{
    cin >> n;

    cin >> str;
    for (int i = 0; i < 2 * n; i++)
    {
        cin >> id[i];
        if (str[i] == 'B')
        {
            posB[id[i]] = i;
        }
        else
        {
            posR[id[i]] = i;
        }
    }
}


int main()
{
    init1();

    pre_cost();
    memset(dp, 0x3f, sizeof(dp));
    dp[0][0] = 0;

    for (int i = 0; i <= n; i++)
    {
        for (int j = 0; j <= n; j++)
        {

            if (i - 1 >= 0)
            {
                dp[i][j] = min(dp[i - 1][j] + cost_B(i, j), dp[i][j]);
               
            }
            if (j - 1 >= 0)
            {
                dp[i][j] = min(dp[i][j], dp[i][j - 1] + cost_R(j, i));
               
            }
        }
    }
    cout << dp[n][n];

    return 0;
}