2020牛客暑假多校训练二

暂时更新前七道题(按难度排序)

D.Duration

题意:

求给出时间的秒差

题解:

统一转换为秒,然后取相减的绝对值

时间复杂度:O(1)

C.Cover the Tree

题意:

给一棵无根树,求最少的链覆盖所有的边,并输出任意符合条件的结果集合

题解:

对于一颗树而言,我们取入度为1的作为叶子,以其中任意一个大于1度的作为根结点。我们会发现,叶子结点到其父节点的边是不会被重叠覆盖,除非使用两次该叶节点作为链的端点。所以要使得最小链覆盖所有,即将叶子结点进行不重复的两两匹配,从而将树完全覆盖。所以链个数的下界即为 $⌈\frac{s}{2}⌉ $

而对于 \(n\leq2\) 的情况,结果显然。而 \(n > 3\) 则是 取dfs序 进行排序,将前 \(n/2\) 化为一组,后 \(n/2\) 化为另一组,然后匹配

证明:

设某边儿子结点所覆盖的叶子结点范围为 \([L,R]\)

如果在\([L,R]\) 范围内的某叶子结点,与该范围以外的某叶子结点相匹配,则此边一定会被经过

· 如果 \(R\leq \frac{n}{2}\) 那么此边必定会被 \(R - R+\frac{n}{2}\) 覆盖

· 如果 \(L> \frac{n}{2}\) 那么此边必定会被 \(L-\frac{n}{2} — L\) 覆盖

· 如果\(R> \frac{n}{2} 且 L \leq \frac{n}{2}\) 则必定存在 \(x\in [L,n/2] 或者 [n/2+1,R] 与 L+\frac{n}{2} 和 R -\frac{n}{2} 匹配\)

从而使得此边被覆盖

否则,根的度数不为1,所以 l ≠ 1或者 r ≠ s 必有一个是满足的;l ≠ 1可以得出,这条边在l 1- l s/2+1; r ≠ s,这条边被 l s/2- ls 覆盖;

s点为奇数时,只需根据叶子结点再接一个节点

时间复杂度:O (n)

F.Fake Maxpooling

题意:

给出 \(n\times m\) 的矩阵,其中 \(A_{i,j}=lcm(i,j)\) ,给出 \(k\) 求出,所有大小为 \(k\) 的子矩阵中的最大值的和.

注意不是 "和的最大值"

范围\(n,m,k (1≤n,m≤5000,1≤k≤min \{n,m \})\)

题解:

对于求在大矩阵中求 给出子矩阵的最值,有以下常见的方法

DP , 单调队列,优先队列,倍增ST表

已知 lcm(a,b) = a*b/gcd(a,b) ,又n,m<5000 ,gcd() 的 时间复杂度大约为 log(n) , 所以对于每个位置的值 :5000 x 5000 x log(5000) ~ 1e8

而这里时间限制大概在3s左右,可能数据没有卡好, \(O(nmlogn)\) 基本上没有 \(TLE\)

题解中给出了 \(O(nm)\)\(A_{i,j}的gcd\) 的方法,利用倍数,类似埃式筛。对于筛出任何互质的 (i,j) ,以及其倍数

for(int i=1;i<=n;i++){
    for(int j=1;j<=m;j++){
        if(!gcd[i][j]){
            for(int k=1; k*i<=n&&k*j<=m;k++){
                gcd[i*k][j*k] = k, A[k*i][k*j] = i*j*k;//lcm
            }
        }
    }
}

方法一:即是标程的 【单调队列】\(O(a*b)\)

类似滑动窗口,处理出在行列 范围【i,i+k】的最大值,然后横向维护,纵向维护一次即可

int a[5005][5005];//a为处理出来的 lcm(i,j)
int que[5005];//维护下标
int b[5005][5005];
void func(){
	long long sum = 0;
	for(int i=1;i<=n;i++){
		int l=1,r=1;
		for(int j=1;j<=m;j++){
			while(r>l && j-que[l] >= k) ++l;
			while(r>l && a[i][j]>a[i][que[r-1]]) --r;
			que[r++] = j;
			if(j>=k) b[i][j-k+1] = a[i][que[l]];
		}
	}
	//横向于纵向维护方式一样 
	for(int j=1;j<=m-k+1;j++){
		int l=1,r=1;
		for(int i=1;i<=n;i++){
			while(r>l && i-que[l] >= k) ++l;
			while(r>l && b[i][j]>b[que[r-1]][j]) --r;
			que[r++] = i;
			if(i>=k) sum += b[que[l]][j];
		}
	}
	cout<<sum<<endl;
}

方法二: 【递推/倍增】\(O(a*b*log(k))\)

要求出范围为 k*k 的矩阵最值,我们可以采用递推的方法

递推公式 \(maxv(i,j,k) 标识 以(i,j) 为左上角,大小为k的矩形最值\)

\(maxv(i,j,k)=max\{maxv(i,j,k-1), maxv(i+1,j+1,k-1), maxv(i+1,j,k-1), maxv(i,j+1,k-1)\}\)

这样时间复杂度会达到 \(O(a*b*k)\) , 但这样明显会超时 最坏便是5000^3

由于 \(O(a*b)\) 为复杂度下限,所以主要考虑如何优化 k

我们可以考虑倍增的思想 (其实也是基于分治的思想):

\(maxv(i,j,k)=max\{maxv(i,j,k), maxv(i+2^{(k-1)},j+2^{(k-1)},k-1),\)

\(maxv(i,j+2^{(k-1)},k-1), maxv(i+2^{(k-1)},j,k-1) \}\)

其他就是主要注意一下关于处理范围的取舍. 由于数据不是那么严格所以 \(O(a*b*log(k))\) 能过

void func(){
	long long sum = 0;
	int lok;
	lok=floor(log2(k));
	for(int l=0;l<=lok-1;l++){
		for(int i=1;i+(1<<l)<=n;i++){
			for(int j=1;j+(1<<l)<=m;j++){
				a[i][j] = max(a[i][j], max(a[i+(1<<l)][j+(1<<l)], max(a[i+(1<<l)][j], a[i][j+(1<<l)])));//最后处理出来的大小为 2^lok
			}
		}
	}
	
	for(int i=1;i<=n-k+1;i++){
		for(int j=1;j<=m-k+1;j++){
			sum += max(a[i][j],max(a[i+k-(1<<lok)][j+k-(1<<lok)],max(a[i+k-(1<<lok)][j],a[i][j+k-(1<<lok)])));
		}
	}
	cout<<sum<<endl;
}

B.Boundary

题意:

给出在二维平面上的 \(n\) 个点,其中 \((0,0)\) 必定在该圆的边界上,找到一个圆,使得在该圆边界上的点数最多.

题解:

考虑暴力情况: 枚举两个点,再枚举其他点是否再该圆上 (找出圆心,两中弦垂线交点) \(O(n^3)\)

思路一:

利用同弧所对圆周角相等(充分条件),可以求出圆周角,判断是否相同。

由于是充分条件,所以在圆周角相同时还需要增加 $\overrightarrow{OP} \times \overrightarrow{OA} >0 $

通过增加方向判断可以得到同侧的圆周角相等时对应同弧。最后取众数即可

二维向量叉乘公式 \(a(x_1,y_1),b(x_2,y_2)\) , \(\overrightarrow{a} \times \overrightarrow{b}=(x_1*y_2-x_2*y_1)\) 交叉相乘再相减

思路二:

可以利用三点求圆心公式,求得圆心坐标,以出现的最多次数作为结果

有圆上三点为(x1,y1),(x2,y2),(x3,y3)

img
设圆的公式如下:
\(Ax^{2}+Ay^{2}+Bx+Cy+D=0\)
系数由如下行列式求得:

\(A=\begin{vmatrix} x_{1}& y_{1} & 1\\ x2& y2& 1\\ x3& y3& 1 \end{vmatrix}\)
\(=x_{1}(y2-y3)-y_{1}(x2-x3)+x2x3-x3x2\)

\(B=-\begin{vmatrix} x_{1}^{2}+y_{1}^{2}& y_{1} & 1\\ x_{2}^{2}+y_{2}^{2}& y_{2}& 1\\ x_{3}^{2}+y_{3}^{2}& y_{3}& 1 \end{vmatrix}\)
\(= (x_{1}^{2}+y_{1}^{2})(y_{3}-y_{2})+ (x_{2}^{2}+y_{2}^{2})(y_{1}-y_{3})+(x_{3}^{2}+y_{3}^{2})(y_{2}-y_{1})\)

\(C=\begin{vmatrix} x_{1}^{2}+y_{1}^{2}& x_{1} & 1\\ x_{2}^{2}+y_{2}^{2}& x_{2}& 1\\ x_{3}^{2}+y_{3}^{2}& x_{3}& 1 \end{vmatrix}\)
\(=(x_{1}^{2}+y_{1}^{2})(x_{2}-x_{3})+ (x_{2}^{2}+y_{2}^{2})(x_{3}-x_{1})+(x_{3}^{2}+y_{3}^{2})(x_{1}-x_{2})\)

\(D=-\begin{vmatrix} x_{1}^{2}+y_{1}^{2}& x_{1} & y_{1}\\ x_{2}^{2}+y_{2}^{2}& x_{2}& y_{2}\\ x_{3}^{2}+y_{3}^{2}& x_{3}& y_{3} \end{vmatrix}\)
\(=(x_{1}^{2}+y_{1}^{2})(x_{3}y_{2}-x_{2}y_{3})+ (x_{2}^{2}+y_{2}^{2})(x_{1}y_{3}-x_{3}y_{1})+(x_{3}^{2}+y_{3}^{2})(x_{2}y_{1}-x_{1}y_{2})\)

将圆方程化为标准方程:
\((x-(-\frac{B}{2A}))^2+(y-(-\frac{C}{2A})^2)=(\sqrt{\frac{B^{2}+C^{2}-4AD}{4A^{2}}})^{2}\)

将上述系数代入即可解得圆心(x,y)和半径R
\(x=-\frac{B}{2A} = \frac{(x_{1}^{2}+y_{1}^{2})(y_{3}-y_{2})+ (x_{2}^{2}+y_{2}^{2})(y_{1}-y_{3})+(x_{3}^{2}+y_{3}^{2})(y_{2}-y_{1})}{2\times(x_{1}(y2-y3)-y_{1}(x2-x3)+x2x3-x3x2)}\)

\(y=-\frac{C}{2A} = -\frac{(x_{1}^{2}+y_{1}^{2})(x_{2}-x_{3})+ (x_{2}^{2}+y_{2}^{2})(x_{3}-x_{1})+(x_{3}^{2}+y_{3}^{2})(x_{1}-x_{2})}{2\times(x_{1}(y2-y3)-y_{1}(x2-x3)+x2x3-x3x2)}\)

\(r=\sqrt{\frac{B^{2}+C^{2}-4AD}{4A^{2}}}\)

Code:

const int maxn = 2e6+5;
struct Node{
    double x,y;
}node[maxn];
int ans ;

map<pair<double,double>,int>mp;
//由于其中一个点为(0,0)

void solve(Node a,Node b){ 
    double x = ((a.x*a.x+a.y*a.y)*(b.y)-(b.x*b.x+b.y*b.y)*(a.y))/(2.0*(a.x*b.y-a.y*b.x));
    double y = ((a.x*a.x+a.y*a.y)*(b.x)-(b.x*b.x+b.y*b.y)*(a.x))/(2.0*(a.y*b.x-a.x*b.y));
    mp[{x,y}]++;
    ans=max(ans,mp[{x,y}]);
}

int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>node[i].x>>node[i].y;
    }
    
    for(int i=1;i<=n;i++){
        mp.clear();
        for(int j=i+1;j<=n;j++){
            if(node[i].x*node[j].y==node[i].y*node[j].x) continue; //不能关于原点对称
            solve(node[i],node[j]);
        }
    }
    cout<<ans+1<<endl;
    return 0;
}

J.Just Shuffle

题意:

给出长为 \(n\) 的排列 以及一个整数 \(k\) , 你要找到一个置换排列 \(P\) 是的通过对\(\{1,2,...,n\}\) 进行\(k\) 次置换操作,得到 \(A\) 排列。如果存在 \(P\) 则输出任意,否则输出 \(-1\) . (输出的置换规律P即为 对\(\{1,2,...,n\}\)进行第一次置换的结果)

范围:\(n,k (1≤n≤10^5,10^8≤k≤10^9)\)

题解:

这里涉及到 置换群 以及 逆元

参考下面博客的内容:

https://blog.csdn.net/qq_36102055/article/details/107456175

置换概念

对于一个n个元素集合S={a1,a2...an},排列P={p1,p2...pn},将排列P每个元素当做S的下标替换掉原本S每个元素的位置,就得到一个置换\(f=\{a_{p1},a_{p2}...a_{pn}\}\)

通过多次置换,可以发现规律:

排列 A=(2,3,1,5,4)

1.置换是可以分成块的:也就是(2,3,1)和(4,5)这两个块,你可以发现无论怎么置换都不会发生这两个集合的元素之间互换。
2.存在循环:也就是对于每个块,在置换一定次数之后就会变回原样,比如(2,3,1)这个块在置换三次后就会变回原来排列中的位置
3.每个环的(下面不叫块了叫环)循环的大小就是块的元素的数目

可以证明所有的置换都可以拆成若干个环w1,w2...wn, 而每个环的大小为r1,r2...rn,也就是说对于环wi在对原排列置换ri次后保持不变,那么也就可以得到原排列置换lcm(r1,r2...rn)次后保持不变。

关系

\(C = lcm(r_1,r_2,..,r_n)\)

\(A^C = A\)

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define ll long long
#define pb push_back
#define eps 1e-8
#define endl '\n'
using namespace std;
const ll maxn = 1e6 + 5;
int n,k,a[maxn],ans[maxn];
bool vis[maxn];
vector<int> v;
void setinv(){
    int r = v.size(),inv;//r为环的大小,inv为k在r下的逆元
    for(int i = 0; i < r; i++)
        if((ll) k * i % r == 1)inv = i;//求逆元
    for(int i = 0; i < r; i++)
        ans[v[i]] = v[(i + inv) % r];//转inv次
}
int main(){
    scanf("%d %d",&n,&k);
    for(int i = 1; i <= n; i++)
        scanf("%d",a + i);
    for(int i = 1; i <= n; i++){
        if(!vis[i]){
            v.clear();
            int x = a[i];
            while(!vis[x]){//找环操作
                v.push_back(x);
                vis[x] = 1;
                x = a[x];
            }
            //找到环后就处理该环所有位置的值
            setinv();
        }
    }
    for(int i = 1; i <= n; i++)
        printf("%d ",ans[i]);
    return 0;
}

A.All with Pairs

题意:

给定n个字符串,求所有字符串最长的前缀与后缀相等长度的平方和。
如样例,匹配长度为1,2,3的分别有4,4,1个,所以答案为\(4×1^2+4×2^2+1×3^2=29\)

范围: \(n,(1≤n≤10^5)\) \(\sum|s_i|\leq10^6\)

题解:

首先思考暴力的方法 n 为个数,m为长度

\(O(n\times m)\)利用map记录后缀出现次数​ + \(O(n^2)\) 枚举两个点 x \(O(m)\) 遍历前缀长度\计算总和

这个复杂度快 \(O(n^3)\) 了,所以需要思考如何简化复杂度

考虑使用 进制hash 求出所有的后缀值,并保存于map中(相对map 好点)

\(O(n \times m)\) 求出后缀出现次数 , 再 \(O(n \times m)\)遍历n个字符串的前缀值,出现与后缀相同则相加。但是原题中要求求出最长匹配,所以要减去前面多加的长度。可以使用 next[] 数组

例如 \(aba\)\(aba\) 匹配的时候:

能够匹配到 \(a,aba\) 由于要求最长的作为 贡献值,所以一开始 加上 \(a\) 的贡献之后就需要被剪掉。

我们知道 next[] 数组记录上一次前缀出现相同长度的位置,所以减去该位置长度即可

//给定n个字符串,求所有字符串最长的前缀与后缀相等长度的平方和。
//如样例,匹配长度为1,2,3的分别有4,4,1个,所以答案为
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
const int maxn = 1e6+5;
const ull mod = 998244353;
string str[maxn];
int nex[maxn];
map<ull,ull>Hsh;
const ull base = 131;
void getNext(string s){
    int i=0,j=-1;
    nex[i] = j;
    while(i<(int)s.length()){
        if(j==-1 || (s[i] == s[j])){
            i++,j++;
            nex[i] = j;
        }else j = nex[j];//向前匹配位置移动
    }
}
void getHash(string s){
    ull ans = 0;
    ull bas = 1;
    for(int i=s.length()-1;i>=0;i--){
        ans = (s[i]*bas + ans);
        bas *= base;
        Hsh[ans]++;
    }
}
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>str[i];
    ull ans = 0;
    for(int i=1;i<=n;i++) getHash(str[i]);
    for(int i=1;i<=n;i++){
        ull res = 0;
        getNext(str[i]);
        for(int j=0;j<(int)str[i].length();j++){
            res = (res*base+str[i][j]);
           // cout<<res<<" "<<Hsh[res]<<endl;
            ans = (ans + Hsh[res] * (j+1) % mod *(j+1) %mod)%mod ;//个数
            ans = (ans - Hsh[res] * nex[j+1] % mod *nex[j+1] % mod + mod)%mod;
            ans = (ans%mod+mod)%mod;
        }
    }
    cout<<ans<<endl;
    return 0;
}
    

G.Greater and Greater

题意:

给一个大小为 \(n\) 的序列 \(A\) , 和一个大小为 \(m\) 的序列 \(B\) ,求出长为 \(m\)\(A\) 中的子区间,使得\(S_i\geq B_i\) \(i\in\{1,2,..,m\}\)

范围:

\(n,m (1≤n≤150000,1≤m≤min\{n,40000\}).\)

\(1\leq A_i,B_i\leq10^9\)

思路:

如果最粗暴的方式去匹配 复杂度为 \(0(nm)\) , 大概6e9 左右,那肯定超时了。

所以如何优化,或者通过什么去记录状态,便于判断?

我们可以用bitset维护状态,用一个 bitsetf[m] , 维护\(A\) 的每个位置与比 \(b_j\) 的关系。

那么要使得 子区间 S 的每一位大于 B 的每一位,只需要在对位上,所有的都符合大于 \(S_j>B_j\) 的关系即可。

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+100;
bitset<N>ans,f;
struct node{
    int pos, x;
    bool operator < (const node &A) const {
        return x > A.x;
    }
}a[N],b[N];
int n,m;
int main(){
    scanf("%d%d",&n,&m);
    for (int i = 1; i <= n; ++i)
        scanf("%d",&a[i].x), a[i].pos = i;
    for (int i = 1; i <= m; ++i)
        scanf("%d",&b[i].x), b[i].pos = i;
    sort(a+1,a+n+1);
    sort(b+1,b+m+1);
    ans.set(); f.reset();

    for (int i = 1, j = 0; i <= m; ++i){
        while((j+1) <= n && a[j+1].x >= b[i].x){
            f[a[j+1].pos] = 1;
            j++;
        }
        ans &= (f >> b[i].pos);
    }
    printf("%d\n",(int)ans.count());
    return 0;
}

H.Happy Triangle

题意:

给出一个 multiset \(MS\) 和 q 次操作,\(MS\) 一开始是空的,有以下三种类型操作

1.插入 \(x\) 到 MS 中

2.删除 \(x\) 在 MS 中

3.给出一个 \(x\) , 是否能在 MS 中找到两个元素 a,b 使得与 \(x\) 一起构成 nondegenerate triangle

(三点不共线的三角形)

思路:

posted @ 2020-07-30 21:15  Tianwell  阅读(171)  评论(0编辑  收藏  举报