LeetCode155周周赛

最新推荐文章于 2021-08-18 18:08:44 发布

GOD_Dian

最新推荐文章于 2021-08-18 18:08:44 发布

阅读量216

点赞数

分类专栏： PTA、蓝桥杯、leetocde、洛谷

本文链接：https://blog.csdn.net/qq_39685968/article/details/101217522

版权

PTA、蓝桥杯、leetocde、洛谷专栏收录该内容

39 篇文章 2 订阅

订阅专栏

赛题链接：https://leetcode-cn.com/contest/weekly-contest-155

赛题重述

《最小绝对差》
给你一个数组，每个元素都不同，要你求数组中任意两元素的差值中最小的那个，并将差值为该最小值的元素对输出。
《丑数》
给一个定义：给定三个数a，b，c。能被这三个数中任意一个整除的数叫做丑数。（此定义并非丑数的真实定义）给定一个整数n，要你求出从1开始的自然数列中的第n个丑数。
《交换字符中的元素》
给定一个字符串s，以及一些“下标对”，或者叫做“索引对”数组 pairs。其中pairs[i]=[a,b]表示字符串中的两个索引（编号从0开始）。对于字符串中索引指向的字符，可以“任意多次”地交换。现在请你返回经过若干次交换后，可以得到的字典序最小的字符串。
《项目管理》

思考

第一题，特别眼熟，是李春葆《算法分析与设计》第一章的课后习题第12题。思路也很简单直接：
（1）对数组排个序（升序）
（2）用一个变量记录相邻元素的差值，并不断与后面的元素之差相比较，记录下较小者。
（3）用循环遍历数组依次比较相邻元素的差值与最小差值是否相等，若相等则输出元素对。

#include<iostream>
#include<algorithm>
#include<vector>
#define input 8//设置向数组中输入多少个数
using namespace std;
class Solution {
public:
    vector<int> num;
	vector<int>::iterator it;
//    minimumAbsDifference(num); 
    vector<vector<int> > minimumAbsDifference(vector<int>& arr) {
		vector<vector<int> > mini;
		vector<int>::iterator it;
		vector<vector<int> >::iterator iter;
        sort(arr.begin(),arr.end());//步骤一排序
        for(it=arr.begin();it<arr.end();it++){
        	cout<<*it<<endl;
		}
		int t=*(arr.end()-1)-*arr.begin();//t记录最小差值 
		for(it=arr.begin()+1;it<arr.end();it++){//循环遍历，寻找相邻差中最小的那个 
			int k=*(it)-*(it-1);//变量k记录从第1项开始，后项与前一项的差值 
			if(t>k){
				swap(t,k);
			}
		}
		// cout<<"最小差值为："<<t<<endl; 
		for(it=arr.begin()+1;it<arr.end();it++){//循环遍历,寻找差值与记录下的值相等的元素对 
			vector<int> vec;
			if(t==*(it)-*(it-1)){//找到了元素对 
				// cout<<*(it-1)<<" "<<*it<<endl;
				vec.push_back(*(it-1));
				vec.push_back(*it);
				mini.push_back(vec);
			}
		}
		// cout<<"已经找完元素对"<<endl; 
		//输出结果
		cout<<mini.size()<<endl;
		 for(int i=0;i<mini.size();i++){
		 	for(int j=0;j<2;j++){
		 		cout<<mini[i][j]<<" ";
		 	}
		 } 
		return mini;
    }
};
int main()
{
	Solution my;
	for(int i=0;i<input;i++){
		int k=0;
		cin>>k;
		my.num.push_back(k);
	}
	my.minimumAbsDifference(my.num);
	return 0;
}

第二题，找第n个丑数。
最开始的想法就是暴力法，从1开始循环判断是否能被三个数整除，但是很显然会超时。这里用的是别人的思路，为避免超时，用二分的思想，将我们一个个对应着找第多少个“丑数”，转换成直接判断在该范围内有多少个丑数。也就是1-mid中有多少个丑数，这个个数用集合论中的容斥原理求解，在丑数个数大于n或小于n的时候，调整范围。直至找到这个满足1~mid内有n个丑数的mid。最后，由于由多个满足条件的mid值，从大到小找满足上述条件最小的那个mid，也即用一个循环判断，循环体中：mid–。

class Solution {
public:
    typedef long long ll;
    ll gcd(ll m,ll n)//最小公倍数 
{
	ll t,r;
	if(m<n)
	swap(m,n); //交换二者的值
	while(n!=0)
	{
		r=m%n;
		m=n;
		n=r;
	}
	return m;
}
    
ll lcm(ll m,ll n)
{
	return (m*n)/gcd(m,n); 
}

ll Floor(ll maxnum,ll a,ll b,ll c)//求0到上限maxnum范围内，能被a或b或c整除的数有多少个 
{
	//利用容斥原理求个数
	 return (maxnum/a+maxnum/b+maxnum/c-(maxnum/lcm(a,b)+maxnum/lcm(a,c)+maxnum/lcm(b,c))+maxnum/lcm(lcm(a,b),c));
}

    ll nthUglyNumber(ll n, ll a, ll b, ll c) {
        ll mid=0,r=0,l=1;//mid为中值，r为右上限，l为左下限
        	r=2*pow(10,9)+1;
	        mid=(r+l)/2;
	        while(Floor(mid,a,b,c)!=n){
		        if(Floor(mid,a,b,c)>n){
			        r=mid-1;
		        }else if(Floor(mid,a,b,c)<n){
			        l=mid+1;
		        }
	        mid=(r+l)/2;
	    }
	   	//问题在于用Floor判断时，是用的集合的方法，有多个mid值对应着相同的n
		//我们需要的是，这多个mid值中最小的那个，用以代表从1开始找丑数，找到的第n个丑数 
		while(!(Floor(mid,a,b,c)==n&&Floor(mid-1,a,b,c)!=n)){
			mid--;
		}
	    return mid;
    }
};

第三题。考虑到如果有两个索引对pairs[i]与pairs[j]中四个元素有相同的，比如说（0，1）与（1，2），则其实实际上索引对（0，1，2）对应的字符可以任意排序。基于这个思路，我们可以按照以下步骤求解：

[1]将索引对中元素有交叉的合并成一个索引组，该索引组中对应元素可以任意排序。
[2]按照上述分组，将每一组依据字典最小序排列。
[3]将上述排列好的组复原至原字符串。

/*
代码来自王同学的博客，详情见文底链接
*/
#include<bits/stdc++.h>
using namespace std;
vector<int> father,sz;
int find(int x){  // 并查集  查
	return father[x]==x?x:father[x] = find(father[x]);
}
string smallestStringWithSwaps(string s,vector<vector<int> > pairs){
	int n=s.size();
	father.resize(n);
	sz.resize(n); 
	for(int i=0;i<n;i++){  // 初始化 
		father[i] = i;
		sz[i] = 1;
	}
	int n1 = pairs.size();
	for(int i=0;i<n1;i++){
		vector<int> tmp = pairs[i];
		int f1 = find(tmp[0]),f2=find(tmp[1]);
		if(f1!=f2){
			if(sz[f1]<sz[f2]){
				father[f1] = f2;
				sz[f2] += sz[f1];
			}
			else{
				father[f2] = f1;
				sz[f1] += sz[f2];
			}
		}
	}
	vector<vector<char> > charArr(n);  
	vector<vector<int> > posArr(n);
	// 并查集发挥作用 
	for(int i=0;i<n;i++){
		charArr[find(i)].push_back(s[i]);
		posArr[find(i)].push_back(i);	
	}
	// char数组排序 
	for(int i=0;i<charArr.size();i++){
		sort(charArr[i].begin(),charArr[i].end());
	}
	// 把排完序的联通块，合到一起 
	string s1(n,'\0');
	for(int i=0;i<n;i++){
		for(int j=0;j<charArr[i].size();j++){
			s1[posArr[i][j]] = charArr[i][j];
		}
	}
	
	return s1;		
}
// 测试下
int main()
{
	string s="cba";
	vector<vector<int> > v;
	vector<int> s1,s2;
	s1.push_back(0);
	s1.push_back(1);
	s2.push_back(1);
	s2.push_back(2);
	v.push_back(s1),v.push_back(s2);
	cout << smallestStringWithSwaps(s,v) << endl; 
	return 0;
}