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] 代码较简单就不贴了
T2(并查集)
大意:大团队里有m个小团队,每个团队有1个或者1个以上的成员,某个成员可能不止属于一个团队。一条消息从编号为0 的员工出发,散布到它所在的团队成员这,知晓消息的人,会将消息扩散到其所在的所有团队。
**分析:**换个方式说,0号知道消息了,告诉了他朋友(同一团队的人),他的朋友们又将消息传达给各自的朋友们,in short->朋友的朋友是朋友!!!
那就是裸的并查集了。不过据说数据有问题,比题目中描述了大了,不少了wa了(我习惯开大一些的数组。。。。)
代码:
#include
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
对于本题
我们考虑也用类似的“插入”法,将黑棋的前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+1n的**白棋**,(因为1j的白棋已经在新数组了,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
#include
#include
#include
#include
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;
}