GDUT22级寒假训练专题五

题解

B - Chamber of Secrets

传送门

题意

  密室是一个$n\times m$的矩形网格，其中一些单元格有柱子(‘#’)。蛇怪视线从右下角向左出发，遇到被施法柱子可以折射到上下左右四个方向，对若干柱子施法，使蛇怪的视线折射到左上角(向左)。对尽可能少的柱子施法，达到这个目标。(没被施法的柱子等于空格，达不成目标输出-1)
$2\le n,m\le 1000$

思路

  比较隐蔽的单源最短路。柱子相当于一条无向边，连通其所在的行和列，连通的代价为1。
  位于$(i,j)$的柱子可以将$i$行和$j$列连通，根据数据范围，可以转化为为$i$与$j+1000$之间有一条无向边,边权为1。题目可以转为求从1到n的最短路。

代码

#include <bits/stdc++.h>
using namespace std;

int n, m;
int dis[2005], vis[2005] = { 0 };
vector<int> e[2005]//邻接表
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> n >> m;
	memset(dis, 0x7f7f7f7f, sizeof(dis));//初始化距离
	char temp;
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
		{
			cin >> temp;
			if (temp == '#')
			{
				e[i].push_back(j + 1000);
				e[j + 1000].push_back(i);//连边
			}
		}
	deque<int> list;
	list.push_back(1), dis[1] = 0, vis[1] = 1;
	while (!list.empty())
	{
		int x = list.front();
		for (int i = 0; i < e[x].size(); i++)
		{
			int nx = e[x][i];
			if (dis[nx] > dis[x] + 1)
			{
				dis[nx] = dis[x] + 1;
				if (vis[nx] == 0)
				{
					vis[nx] = 1;
					list.push_back(nx);
				}
			}
		}
		list.pop_front();
		vis[x] = 0;
	}
	if (dis[n] == dis[0])//到达不了
		cout << -1;
	else
		cout << dis[n];
	return 0;
}

G - 逆序对

传送门

题意

  TOM 老猫查阅到一个人类称之为“逆序对”的东西，这东西是这样定义的：对于给定的一段正整数序列，逆序对就是序列中 $a_i>a_j$且$i<j$的有序对。知道这概念后，他们就比赛谁先算出给定的一段正整数序列中逆序对的数目。注意序列中可能有重复数字。
$n\le 5\times 10^5,a_i\le 10^9$

思路

  首先，逆序对求起来不方便，可以对序列方向存储，求原序列的逆数对就是求反向序列的顺数对。
  对于第$i$个数，前面有多少个比$a_i$小的数，就代表$a_i$与前个$i-1$个数构成多少个顺数对。用一个数组记录每个数的出现次数，枚举序列的每一个数，每次枚举求一次前缀和，再给数组中$a_i$的出现次数加$1$ 即可得到答案。这个操作可以用树状数组实现。
  本题$a_i$范围太大，而判断顺序对只需要相对大小即可，所以可以进行离散化操作。比如:
将$8,1,999,1000000,10,99999999$离散化后变成$2,1,4,5,3,6$，离散化后$a_i\le n$。
  但是序列中会出现相同数字，通过排序离散化，会将其变为不同的数字，导致$wa$。因为前缀和操作只统计比自己小的数出现次数,所以只需要使相同数字中出现早的数字离散化后更大，在运算过程中就不会出错比如:将$3,2,2,8,3,3$离散化后变成$5,2,1,6,4,3$即可。

代码

#include <bits/stdc++.h>
using namespace std;
int n, c[500005] = { 0 }, a[500005], b[500005];
inline int lowbit(int x)
{
    return x & (-x);
}
void add(int x, int num)
{
    for (; x <= n; x += lowbit(x))
        c[x] += num;
}
int getsum(int x)
{
    int sum = 0;
    for (; x > 0; x -= lowbit(x))
        sum += c[x];
    return sum;
}
bool cmp(int x, int y)//离散化排序
{
    if (a[x] != a[y])//不相等小的在前
        return a[x] < a[y];
    else//相等后出现的在前
        return x > y;
}
int main()
{
    long long ans = 0;
    scanf("%d", &n);
    for (int i = n; i >= 1; i--)//反向输入
    {
        scanf("%d", &a[i]);  
        b[i] = i; //标记排序前位次
    }
    sort(b + 1, b + n + 1, cmp);
    for (int i = 1; i <= n; i++)
        a[b[i]] = i; //离散化
    for (int i = 1; i <= n; i++)//枚举
    {
        add(a[i], 1);
        ans += getsum(a[i] - 1);
    }
    printf("%lld", ans);
    return 0;
}

J - Lost Cows

传送门

题意

  $N$头牛，每头牛有一个独一无二的品牌值，品牌值在$[1,N]$内。现在这些牛随机排成直线。每头牛都知道前面有多少头牛的品牌值小于它，求出每头牛的品牌值。
$2\le N\le 8000$

思路

  首先，对于第$i$头牛，假如前面有$x$头牛的品牌值小于它，说明它在前$i$头牛中排$x+1$位。
  知道这一点，就可以从最后一头牛开始枚举每一头牛，将每一头牛安排在N个位置中的
第$x+1$个空位置中，位置编号就是这头牛的品牌值。由于本题数据量小，暴力枚举每一个位置，已经可以$AC$。
  对于第$i$个位置可以用前缀和的方式求出前$i$个位置中有多少个空位置，用树状数组实现前缀和的维护，在[1,8000]内二分找到第一个前面及这个位置本身恰有$x+1$个空位置的位置编号，位置编号就是这头牛的品牌值。二分查找位置编号可以降低时间复杂度。

代码

暴力枚举代码:

#include <bits/stdc++.h>
using namespace std;

int main() 
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int n;
	cin >> n;
	int a[8005];
	int vis[8005] = { 0 };
	a[1] = 0;
	for (int i = 2; i <= n; i++)
		cin >> a[i];
	for (int i = n; i >= 1; i--)
	{
		int x = a[i];
		for (int j = 1; j <= n; j++)
		{
			if (vis[j])
				continue;
			if (!x)
			{
				vis[j] = 1;
				a[i] = j;
				break;
			}
			else
				x--;
		}
	}
	for (int i = 1; i <= n; i++)
		cout << a[i] << endl;
	return 0;
}

树状数组代码:

#include <bits/stdc++.h>
using namespace std;

int n, b[8005] = { 0 };
inline int lowbit(int x)
{
    return x & (-x);
}

void add(int x, int num)
{
    for (; x <= n; x += lowbit(x))
        b[x] += num;
}

int getsum(int x)
{
    int sum = 0;
    for (; x > 0; x -= lowbit(x))
        sum += b[x];
    return sum;
}

inline int check(int x)
{
	return x - getsum(x);
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	int a[8005];
	a[1] = 0;
	for (int i = 2; i <= n; i++)
		cin >> a[i];
	for (int i = n; i >= 1; i--)
	{
		int l = 1, r = 8000;
		while (l != r)
		{
			int mid = (l + r) / 2;
			if (check(mid) < a[i] + 1)
				l = mid + 1;
			else
				r = mid;
		}
		add(r, 1);
		a[i] = r;
	}
	for (int i = 1; i <= n; i++)
		cout << a[i] << endl;
	return 0;
}