东华进阶oj61-70

已于 2022-03-01 22:10:42 修改
阅读量306 收藏 1
点赞数 1
文章标签： c语言 算法 c++ 蓝桥杯 东华进阶oj
于 2022-03-01 20:29:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51183095/article/details/123214451
版权

在这里插入图片描述
在这里插入图片描述

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<vector>
#include<stack>
#include<set>
#include<queue>
#include<cstring>
#define ll long long
using namespace std;

int a[9];

int main()
{
    for(int i=0;i<9;i++)
        a[i]=i+1;///数字1-9
    int n,x,b,c,ans=0;
    scanf("%d",&n);
    do
    {
        x=0;
        for(int i=0;i<6;i++)/// n<= 1000000
        {
            x=x*10+a[i];
            if(x<n)
            {
                int idx=(8-i)/2;///对x后面的数位折半 确保b>c
                while((i+idx)<8)
                {
                    b=0;c=0;
                    int j;
                    for(j=i+1;j<=(i+idx);j++)
                        b=b*10+a[j];
                    for(;j<9;j++)
                        c=c*10+a[j];
                    if(b%c==0 && b>c && n==(x+b/c) )
                        ans++;
                    idx++;
                }
            }
        }
    }while(next_permutation(a,a+9));///对数组a里下标为0到下标为8这九个数全排列
    printf("%d\n",ans);
    return 0;
}

在这里插入图片描述

#include <bits/stdc++.h>

using namespace std;

int r,c,k;
int mp[15][15];
bool vis[15][15];
int ans = 9999999;   //最少的格子数 
int all;
int dir[4][2] = {{-1,0},{0,-1},{1,0},{0,1}};

void dfs(int x, int y, int cnt, int sum){ 
 // cnt是已走过格子数，sum已走过格子数字总和
	
	if(x < 0 || x >= r || y < 0 || y >= c || vis[x][y]){
		return;
	}
	
	if(sum + mp[x][y] == all / 2){
		ans = min(ans,cnt+1);
		return;
	}
	
	vis[x][y] = true;
	for(int i = 0; i < 4; i++){
		dfs(x+dir[i][0],y+dir[i][1],cnt+1,sum+mp[x][y]);	
	}
	vis[x][y] = false;

}

int main(){
	cin >> c >> r;
	
	for(int  i = 0; i < r; i++){
		for(int j = 0 ; j < c; j++){
			cin >> mp[i][j];
			all += mp[i][j];
		}
	}
	if(all % 2 != 0){
		cout << 0 << endl;
		return 0;
	}
	
	dfs(0,0,0,0);
	
	cout << ans << endl;
	
	return 0;
}

在这里插入图片描述

//找最典型规律最简单 
#include<stdio.h>
#include<string.h> 
int main()
{
	char st[1005]={0};
	char ed[1005]={0};
	int f[1005];
	int count=0,i=0;
	scanf("%s %s",st,ed);
    while(st[i]!='\0')
    {
      if(st[i]==ed[i])
       {
    	 f[i]=0;
	   }
      else
       {
    	 f[i]=1;
  	   }
  	   i++;
	}
	i=0;
	int start=-1;
	while(st[i]!='\0')
	{
	  if(f[i]==1)
	  {
	  	 if(start==-1)
	  	   {
	  	 	start=i;
		   }
		   else
		   {
		   	   count+=i-start;
			   start=-1;
		   }
	  }
	  i++;
    }
   printf("%d",count);
	return 0;
}

在这里插入图片描述

#include <iostream>
#include <stdio.h>
#include <string>
#include <algorithm>
#include <math.h>
#include <queue>
#include <stack>
#include <limits.h>
#include <map>

using namespace std;

int n,arr[50005];

void f() {
	int res = n;
	for (int i = 0; i < n; i++) {
		int ma = arr[i];
		int mi = arr[i];
		for (int j = i + 1; j < n; j++) {
			ma = max(ma, arr[j]);
			mi = min(mi, arr[j]);
			if (ma - mi == j - i) {
				res++;
			}
		}
	}
	cout << res << endl;
}

int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> arr[i];
	}
	f();
	return 0;
}

在这里插入图片描述

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
struct Edge{
    int to,next,val;
};
long long max_len;
int max_num,n;
void bfs(int s,long long *dis,Edge *e,int *h){
    //memset(dis,-1,sizeof(dis));
    int top,i;
    for(i=1;i<=n;i++){
        dis[i]=-1;
    }
    queue<int> q;
    q.push(s);
    //vis[s]=true;
    dis[s]=0;

    while(!q.empty()){

        //cout<<max_num<<endl;

        top=q.front();
        q.pop();
        //vis[top]=false;
        for(i=h[top];i+1;i=e[i].next){
            //cout<<i<<endl;
            if(dis[e[i].to]==-1){
                //vis[e[i].to]=true;
                dis[e[i].to]=dis[top]+e[i].val;
                if(dis[e[i].to]>max_len){
                    max_len=dis[e[i].to];
                    max_num=e[i].to;
                }
                q.push(e[i].to);
            }
        }
    }
}
int main(){//树的直径问题
    //freopen("D://INPUT.txt","r",stdin);
    scanf("%d",&n);
    Edge *e=new Edge[n*2+1];
    int *h=new int[n+1];
    long long *dis=new long long[n+1];
    //bool *vis=new vis[n+1];
    int i,num=0;
    int nn=n-1,u,v,val;
    //memset(h,-1,sizeof(h));
    for(i=1;i<=n;i++){
        h[i]=-1;
    }


    for(i=0;i<nn;i++){//建邻接表
        scanf("%d %d %d",&u,&v,&val);
        e[num].to=v;
        e[num].val=val;
        e[num].next=h[u];
        h[u]=num++;

        e[num].to=u;
        e[num].val=val;
        e[num].next=h[v];
        h[v]=num++;
    }
    max_len=-1;
    max_num=1;
    bfs(1,dis,e,h);

    //cout<<max_num<<endl;
    //cout<<max_len<<endl;

    bfs(max_num,dis,e,h);
    cout<<max_len*(max_len+21)/2<<endl;
    delete []e;
    delete []h;
    delete []dis;
    return 0;
}

在这里插入图片描述

#include <stdio.h>
main()
{
    int a,b,c,s;
    do
    {
        scanf("%d%d%d", &a,&b,&c);
    }
    while(a>30&&b>30&&c>30);
    s=f1(a,b);
   // printf("%d\n",s);
    s=f1(s,c);
    printf("%d\n",s);
    return 0;
}

int f1(int a,int b)
{
    int t,m;
    int c;
    if (a < b)
    {
        t = a;
        a = b;
        b = t;
    }
    m = a * b;


    c = a % b;
    while (c != 0)
    {
        a = b;
        b = c;
        c = a % b;
    }

    return m/b;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

const int MAXN = 10000;
const double PI = atan(1.0) * 4;
const double EPS = 1e-10;

class Point {
public:
	double x, y;
	Point() {}
	Point(double x, double y) : x(x), y(y) {}
	Point operator - (const Point &r) const { return Point(x-r.x, y-r.y); }
	Point operator + (const Point &r) const { return Point(x+r.x, y+r.y); }
	Point &operator += (const Point &r) { x += r.x; y += r.y; return *this; }
	Point &operator *= (double m) { x *= m; y *= m; return *this; }
	Point pOfRotate(double angle) const {
		double cosA = cos(angle);
		double sinA = sin(angle);
		return Point(cosA*x-sinA*y, sinA*x+cosA*y);
	}
	Point pOfRotate90() const { return Point(-y, x); }
	double length() const { return sqrt(x*x+y*y); }
	Point pOfNormal() const {
		double len = length();
		return Point(x/len, y/len);
	}
	double angle() const { return atan2(y, x); }
};

ostream & operator <<(ostream &os, const Point &v)
{
	os << "(" << v.x << "," << v.y << ")";
	return os;
}

class Segment;
class Circle;

class Seg {
public:
	virtual double getLeft() const = 0;
	virtual double getRight() const = 0;
	virtual double getY(double x) const = 0;
	virtual double getLength(double x1, double x2) const = 0;
	virtual void intersect(Seg *r) const = 0;
	virtual void intersect(const Segment &v) const = 0;
	virtual void intersect(const Circle &v) const = 0;
	bool contains(double x) const { return x>=getLeft() && x<=getRight(); }
	virtual void acceptPrint(ostream &os) const = 0;
};

ostream & operator <<(ostream &os, const Seg &v)
{
	v.acceptPrint(os);
	return os;
}

Point intersectRet[4];
int tIntersectRet;

class Segment : public Seg {
public:
	Point a, b;
	Segment &moveLeft(double dis)
	{
		Point tmp = ((b-a).pOfRotate90().pOfNormal() *= dis);
		a += tmp;
		b += tmp;
		return *this;
	}
	virtual double getLeft() const { return a.x; }
	virtual double getRight() const { return b.x; }
	virtual double getY(double x) const {
		return (x-a.x)*(b.y-a.y)/(b.x-a.x)+a.y;
	}
	virtual double getLength(double x1, double x2) const {
		return (x2-x1) * (b-a).length() / (b.x-a.x);
	}
	virtual void intersect(Seg *r) const {
		r->intersect(*this);
	}
	virtual void intersect(const Segment &v) const {
		tIntersectRet = 0;
		double ang = (b-a).angle();
		Point c = (v.a-a).pOfRotate(-ang);
		Point d = (v.b-a).pOfRotate(-ang);
		double di = (b-a).length();
		if (!((c.y>0&&d.y<0) || (c.y<0&&d.y>0)))
			return ;
		double x = (d.x-c.x) * (-c.y) / (d.y-c.y) + c.x;
		if (x<0 || x>di)
			return ;
		Point ret = Point(x,0).pOfRotate(ang)+a;
		intersectRet[tIntersectRet++] = ret;
	}
	virtual void intersect(const Circle &v) const;
	virtual void acceptPrint(ostream &os) const {
		os << a << "-" << b;
	}
};

class Circle : public Seg {
public:
	Point c;
	double r;
	virtual double getLeft() const { return c.x - r; }
	virtual double getRight() const { return c.x + r; }
	virtual double getY(double x) const {
		double y2 = r * r - (c.x - x) * (c.x - x);
		if (y2<0) y2 = 0;
		return c.y + sqrt(y2);
	}
	virtual double getLength(double x1, double x2) const {
		x1 -= c.x; x2 -= c.x;
		double a1 = Point(x1, sqrt(abs(r*r-x1*x1))).angle(), a2 = Point(x2, sqrt(abs(r*r-x2*x2))).angle();
		return (a1-a2) * r;
	}
	virtual void intersect(Seg *r) const {
		r->intersect(*this);
	}
	virtual void intersect(const Segment &v) const {
		tIntersectRet = 0;
		Point a = v.a - c;
		Point b = v.b - c;
		double ang = (b-a).angle();
		Point nA = a.pOfRotate(-ang);
		Point nB = b.pOfRotate(-ang);
		double y = nA.y;
		if (y>r || y<-r)
			return ;
		double x = sqrt(r*r - y*y);
		if (x>=nA.x && x<=nB.x)
			intersectRet[tIntersectRet++] = Point(x, y).pOfRotate(ang) + c;
		if (-x>=nA.x && -x<=nB.x)
			intersectRet[tIntersectRet++] = Point(-x, y).pOfRotate(ang) + c;
	}
	virtual void intersect(const Circle &v) const {
		tIntersectRet = 0;
		Point p = v.c - c;
		double d = p.length();
		if (d > r + v.r || d==0)
			return ;
		double x = (r*r - v.r*v.r + d*d) / (2*d);
		if (x <= r)
		{
			double y = sqrt(abs(r*r - x*x));
			double ang = p.angle();
			intersectRet[tIntersectRet++] = Point(x,y).pOfRotate(ang) + c;
			intersectRet[tIntersectRet++] = Point(x,-y).pOfRotate(ang) + c;
		}
	}
	virtual void acceptPrint(ostream &os) const {
		os << c << "," << r;
	}
};

void Segment::intersect(const Circle &v) const {
	v.intersect(*this);
}

int n;
Point inps[MAXN];
vector<Seg *> segs;
vector<double> spes;
double radius = 1;

void input()
{
	scanf("%d%lf", &n, &radius);
	for (int i = 0; i < n; ++i)
	{
		double x, y;
		scanf("%lf%lf", &x, &y);
		inps[i] = Point(x, y);
	}
}

void process()
{
	segs.clear();
	spes.clear();
	for (int i = 1; i + 1 < n; ++i)
	{
		Circle *tmp = new Circle;
		tmp->c = inps[i];
		tmp->r = radius;
		segs.push_back(tmp);
	}
	for (int i = 0; i + 1 < n; ++i)
	{
		Segment *tmp = new Segment;
		tmp->a = inps[i];
		tmp->b = inps[i+1];
		tmp->moveLeft(radius);
		segs.push_back(tmp);
	}
	for (int i = 0; i < (int)segs.size(); ++i)
	{
		spes.push_back(segs[i]->getLeft());
		spes.push_back(segs[i]->getRight());
	}
	for (int i = 0; i < (int)segs.size(); ++i)
	{
		for (int j = i+1; j < (int)segs.size(); ++j)
		{
			segs[i]->intersect(segs[j]);
			if (tIntersectRet > 0)
			{
				for (int id = 0; id < tIntersectRet; ++id)
				{
					spes.push_back(intersectRet[id].x);
				}
			}
		}
	}
	sort(spes.begin(), spes.end());
	double pre = spes[0];
	const double NONE = 1e30;
	double preEnd = NONE;
	double totalLen = 0;
	for (int i = 1; i < (int)spes.size(); ++i)
	{
		if (spes[i]-pre < EPS)
			continue;
		double cur = (pre+spes[i]) / 2;
		if (cur>=inps[0].x && cur<=inps[n-1].x)
		{
			double MY = -NONE;
			int who;
			for (int j = 0; j < (int)segs.size(); ++j)
			{
				if (!segs[j]->contains(cur))
					continue;
				double y = segs[j]->getY(cur);
				if (y > MY)
				{
					MY = y;
					who = j;
				}
			}
			if (preEnd != NONE)
			{
				double LY = segs[who]->getY(pre);
				totalLen += abs(preEnd-LY);
			}
			double len = segs[who]->getLength(pre, spes[i]);
			if (len < 0)
				printf("Error!\n");
			totalLen += len;
			preEnd = segs[who]->getY(spes[i]);
		}
		pre = spes[i];
	}
	printf("%0.2lf\n", totalLen);
	for (int i = 0; i < (int)segs.size(); ++i)
		delete segs[i];
	segs.clear();
}

int main()
{
	input();
	process();
	return 0;
}

在这里插入图片描述
比如：

输入
60

输出
-1

#include <stdio.h>

int main ()
{
	int a,b,c,d,e,f;
	int flag=0;
	int n;
	scanf("%d",&n);
	for(int i=10000;i<999999;i++)
	{
		if(i/100000==0)
		{
			a=i%10;
		    b=((i-a)/10)%10;
			c=((((i-a)/10)-b)/10)%10;
			d=((((((i-a)/10)-b)/10)-c)/10)%10;
			e=((((((((i-a)/10)-b)/10)-c)/10)-d)/10)%10;
			int sum= a*10000+b*1000+c*100+d*10+e*1;
			if(sum==i && a+b+c+d+e==n)
			{
		  		printf("%d\n",sum);
		  		flag=1;
    		}
		}
		else
		{
			a=i%10;
			b=((i-a)/10)%10;
			c=((((i-a)/10)-b)/10)%10;
			d=((((((i-a)/10)-b)/10)-c)/10)%10;
			e=((((((((i-a)/10)-b)/10)-c)/10)-d)/10)%10;
			f=((((((((((i-a)/10)-b)/10)-c)/10)-d)/10)-e)/10)%10;
			int sum= a*100000+b*10000+c*1000+d*100+e*10+f;
			if(sum==i && a+b+c+d+e+f==n)
			{
		 		 printf("%d\n",sum);
		  		flag=1;
    		}
		}
	}   
	if(flag==0)
		printf("-1");
		
	return 0;
}

在这里插入图片描述

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
 
using namespace std;
 
struct node
{
    int x,y,d;
} s[100000+5];
int n,f[10000+5];
 
bool cmp(node a,node b)
{
    return a.d>b.d;
}
 
void Set()
{
    for (int i=1; i<=n; i++)
        f[i]=i;
}
 
int Find(int x)//查找根节点
{
    if (f[x]==x)
        return x;
    return f[x]=Find(f[x]);
}
 
bool Union(int x,int y)
{
    x=Find(x);
    y=Find(y);
    if (x!=y)
    {
        f[x]=y;
        return 1;
    }
    return 0;
}
 
 
int main()
{
    int m;
    while (~scanf("%d%d",&n,&m))
    {
        for (int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&s[i].x,&s[i].y,&s[i].d);
        }
        sort(s+1,s+m+1,cmp);
        Set();
        int pre=-1,ans=0;//表示前一次是在第几天进行反抗的
        for (int i=1; i<=m; i++)
        {
            int way=Union(s[i].x,s[i].y);//way=0表示之前有桥，不需要在建桥
            if (way==1&&s[i].d!=pre)
            {
                ans++;
                pre=s[i].d;
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

在这里插入图片描述

#include <stdio.h>
int main()
{
    int n, k, T;
    long long sum = 1, t=1, a=1;
    scanf("%d%d%d", &n, &k, &T);
    for(int i = 1; i < T; ++i)
    {
        t = (((a+a+n-1)*n/2)+t)%k;
        sum += t;
        a += n;
    }
    printf("%lld\n", sum);
    return 0;
}
澜莲Alice
关注
东华进阶oj51-60
qq_51183095的博客
03-01 636
你是我在深渊之中仰望的月亮。加油！
东华进阶oj31-40
qq_51183095的博客
03-01 811
嘴巴上说什么人各有所长、人各有志、人生有无限可能，实际评价的时候却只局限着一次元的世界。
东华进阶oj41-50
qq_51183095的博客
03-01 437
努力是不会背叛自己的，虽然梦想会背叛。 努力不一定能实现梦想，但是曾经努力过的事实却足以安慰自己。
东华复试进阶oj21-30
qq_51183095的博客
03-01 374
不知道该做什么，所以即使是知道了也没用的事情还是想知道，心里总是很焦急、很焦急，焦急得不得了。
东华进阶oj71-100 【蓝桥杯】
qq_51183095的博客
03-01 735
上元佳节，神武大街，惊鸿一瞥，百世沦陷。算法为灵魂！
东华复试进阶oj11-20
qq_51183095的博客
02-28 142
提高你的适应力，去接受这一切
东华复试进阶oj1-10
qq_51183095的博客
02-28 368
一种是设想所有状况，然后平等地一个个评价后找出唯一解答的凡人; 另一种是把灵光一现当成事实，认定那是正确的方向并提出解答的天才。
东华OJ-进阶T14-芯片测试
m0_47462865的博客
03-18 302
东华OJ-进阶T14-芯片测试 14 芯片测试 作者: Turbo 时间限制: 1S 章节: 深度优先搜索 问题描述 : 有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。 　　每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。 　　给出所有芯片的测试结果，问哪些芯片是好芯片。 输入说明 : 输入数据第一行为一个整数n，表示芯片个数。 　　第二行到第n+
东华OJ-进阶T18-3000米排名预测
m0_47462865的博客
03-18 319
东华OJ-进阶T18-3000米排名预测 18 3000米排名预测 作者: Turbo 时间限制: 1S 章节: 深度优先搜索 问题描述 : 3000米长跑时，围观党们兴高采烈地预测着最后的排名。因为他们来自不同的班，对所有运动员不一定都了解，于是他们分别对自己了解的一些运动员的实力作出了评估，即对部分运动员做了相对排名的预测，并且告诉了可怜留守的班长。因为无聊，于是他们就组团去打Dota去了。比赛结束后他们向班长询问最后的排名，但班长不记得了，只记得他们中哪些人的预测是正确的，哪些人的预测是错
36 数列1(进阶题)----东华大学2020计算机考研复试oj上机题
qq_38003627的博客
03-25 635
问题描述 : 思维的严密性是相当重要的，尤其是在程序设计中，一个小小的错误，就可能导致无法想象的后果。明明的爸爸是一名富有经验的程序设计专家，深知思维严密的重要性。于是在明明很小的时候，就通过游戏的方式训练明明的思维严密性。今天，明明的爸爸和明明做了一个数列的游戏。 这个游戏很简单，就是有一数列，现在需要在数列中选出一个或者连续若干个数，要求这些数的和能被11整除。明明的爸爸想锻炼明明思维的严密性...
32 三艘船(进阶题)----东华大学2020计算机考研复试oj上机题
qq_38003627的博客
03-23 361
问题描述 : 明明由于工作的关系，经常需要坐船到某地出差办事。久而久之，明明就对这两地之间船的班次情况相当了解，他会根据办事的具体情况选择不同班次的船出行。这两地的船一共分为三个班次：特快船、快船、慢船，三个班次的船在同一天的0点从港口出发，并沿着同一路线匀速航行，只是它们到达目的地的时刻不同。 你作为明明的好朋友，有一次和明明在闲聊，问到他出差时船的航行距离有多少时，明明没有正面回答你这个问题，...
数据结构，问题 C: 后缀表达式
nick_912912的博客
10-31 365
所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。如：3*(5–2)+7对应的后缀表达式为：3．5．2．-*7．+@。’@’为表达式的结束符号。‘.’为操作数的结束符号。后缀表达式（保证只包含+-*/四种操作符号，结果在int范围内）
C/C++--10--VS2008编译C语言时如何将const LineA * 里面的值赋值给另外一个结构体LineA？
最新发布
天明宇朗的博客
11-03 452
确保拷贝了整个结构体的内容，如果结构体包含指针或者动态分配的内存，那么只有结构体的部分会被拷贝，指针将指向同一个地址，可能导致不安全。操作符可以用于指针类型，但返回的是指针本身的大小，而不是指针所指向的数据的大小。用于指针类型时，它返回的是指针本身的大小，而不是指针所指向的数据的大小。操作符中，如果使用指针类型，它将返回指针本身的大小，而不是指针所指向的数据的大小。中包含指针指向的动态分配的数据，你需要手动复制这些数据，以保持数据的独立性。指针指向的结构体内的值赋值给另一个结构体，你可以通过使用。
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 503
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
weixin_47868976的博客
10-31 1037
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 407
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
数据结构和算法-01背包问题01-认识01背包
qq_36115196的博客
10-31 246
0-1背包问题： 介绍0-1背包的两种实现方式， 回溯法和动态规划法。
xtu oj 连接字符串
Go offline for a while
10-30 971
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 310
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
杭电oj1000-1100
11-10
杭州电子科技大学在线评测系统（杭电OJ）中的题目1000-1100是一系列编程题，我将分别进行回答。 1000题是一个简单的入门题，要求计算两个整数的和。我们可以使用一个简单的算法，读取输入的两个整数，然后将它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值