大一ACM暑假集训第一周学习总结

第一周总结

加油站跑路问题

/*a为路程点，b为对应点油量，kc为当前油量，hf为油量损耗*/
int n,l,p;
struct c{
    int a,b;
}ab[10010];
priority_queue<int>q;
bool cmp(c a, c b)
{
    return a.a<b.a;		//按车辆经过加油站的顺序排序
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>ab[i].a>>ab[i].b;	//输入
    }
    cin>>l>>p;
    int kc=p;
    for(int i=1;i<=n;i++)
        {
            ab[i].a=l-ab[i].a;
        }
        sort(ab+1,ab+1+n,cmp);	//按车辆经过加油站的顺序排序
        ab[n+1].a=l;		//特殊点的处理
        ab[n+1].b=0;
    int ans=0,hf=0;
    
    /*------------主要算法--------------*/
    for(int i=1;i<=n+1;i++)
    {
        int d=ab[i].a-hf;
        while(d>kc)			//当需要加油时
        {
            if(q.empty())		//判断无解
            {
                cout<<"-1"<<endl;
                return 0;
            }
            ans++;			//有解则加油
            kc+=q.top();
            q.pop();
        }
        kc-=d;				//不需要加油时的处理
        hf=ab[i].a;
        q.push(ab[i].b);
    }
 /*------------主要算法--------------*/
    
    cout<<ans<<endl;
	return 0;
}

每个单词独立翻转（字符串空格问题）

/*n为测试组数，s为串，用a出入栈*/
int main()
{
	int n;
	string s,a;
	cin>>n;
	getchar();
	while(n--)
    {
        
/*------------主要算法--------------*/
        stack<int>t;
        getline(cin,s);		//读入一行到s
        for(int i=0;i<s.size();i++)
        {
            if(s[i]!=' ' && s[i]!='\0')
            {
                t.push(s[i]);  //将单个字符入栈
            }
            else	//当遇到单词间的分界
            {
                while(!t.empty())
                {
                    a=t.top();
                    cout<<a;	//输出栈内所有字符并清空栈
                    t.pop();
                }
                cout<<" ";	//格式空格
            }
        }
            //输出最后一个单词
        while(!t.empty())
        {
            a=t.top();
            cout<<a;
            t.pop();
        }
/*------------主要算法--------------*/

	cout<<endl;
	}
return 0;
}

一组数据的【最长不重复长度】查询

/*visit数组用于记录当前数据是否重复过*/
const int N = 1000000 + 5;
using namespace std;
int visit[N];
int main()
{
    int n;
    int ans=0;
    cin>>n;

/*------------主要算法--------------*/
    queue<int>q;
    for(int i=0; i<n; i++)
    {
        int x;
        cin>>x;
        if(visit[x]==0) //不存在，入队
        {
            q.push(x);
            visit[x]=1;	//标记为已存在
        }
        else	//若存在
        {
            ans=max(ans,(int)q.size());	//更新最长
            while(visit[x]==1)  //直到重复的数出队
            {
                int temp=q.front();
                q.pop();
                visit[temp]=0;	//出队了就还原为未使用过
            }
            q.push(x);	//出完之后再放⼊新数
            visit[x]=1;	//新数被使用
        }
    }
    ans=max(ans,(int)q.size());	//更新最终答案
/*------------主要算法--------------*/

    cout<<ans<<endl;
    return 0;
}

均分一组数，求【最小步数】

/*s为均分目标值，ans为步数*/
const int N = 110;
int a[N];
int main()
{
    int n;
    cin>>n;
    int s=0;
    for (int i = 0; i < n; i ++ )
    {
        cin>>a[i];
        s+=a[i];
    }
    s/=n;
    int ans=0;
    
/*------------主要算法--------------*/
    for (int i = 0; i < n; i ++ )
    {
        if(a[i]!=s)
        {
            ans++;
            a[i+1]-=s-a[i];
            a[i]+=s-a[i];
        }
    }
/*------------主要算法--------------*/

    cout<<ans<<endl;
    return 0;
}

拆分素数

const int N = 100010;
int prime[N],cnt = 0 ;
bool st[N];
/// 线筛打质数表
void get_prime(int x)
{
    for(int i = 2; i <= x; i++)
    {
        if(!st[i])
            prime[cnt++] = i;
        for(int j = 0; prime[j] <= x / i; j++)
        {
            st[prime[j]*i] = true;
            if(i % prime[j] == 0)
                break;
        }
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cout.tie(0);
    cin.tie(0);
    get_prime(N);
    int n;
/*------------主要算法--------------*/
    while(cin >> n)
    {
        if(n == 0)
            break;
        int l = 0, r = 0,ans = 0,sum = 0;
        while(true)
        {
            while( r < cnt && sum < n )
                sum += prime[r++];
            if( sum < n)
                break;
            if( sum == n )
                ans ++;
            sum -= prime[l++];
        }
/*------------主要算法--------------*/
        cout << ans << endl;
    }
    return 0;
}

遍历图BFS

/*在输入的一个二维数组图中进行步数统计、数量统计等*/
char a[23][23];
int m,n,ans=1;
int dx[]={1,-1,0,0};
int dy[]={0,0,-1,1};
void bfs(int x,int y)
{
    queue< pair<int,int> > q;
    q.push(make_pair(x,y));
    a[x][y]='#';
/*------------主要算法--------------*/
    while(!q.empty())		//持续移动
    {
        pair<int,int> no=q.front();
        q.pop();
        int x=no.first,y=no.second;
        for(int i=0;i<4;i++)	//4个方向
        {
            int tx,ty;
            tx=x+dx[i];		//模拟移动
            ty=y+dy[i];
            if(tx>=0 && tx<n && ty>=0 && ty<m && a[tx][ty]=='.')	//判断条件
            {	
                a[tx][ty]='#';
                q.push(make_pair(tx,ty));
                ans++;
            }
        }
    }
/*------------主要算法--------------*/
    cout<<ans<<endl;
}
int main()
{
    int x,y;
    cin>>m>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
    {
        cin>>a[i][j];
        if(a[i][j]=='@')
            x=i,y=j;
    }
    bfs(x,y);
    return 0;
}

遍历图DFS

char a[21][21]={'#'};
int dx[4]={-1,0,1,0};
int dy[4]={0,1,0,-1};
int m,n,x,y,ans=1;
/*------------主要算法--------------*/
void dfs(int x,int y)
{
    a[x][y]='#';
    for(int i=0;i<4;i++)	//四个方向
        {
            int tx,ty;
            tx=x+dx[i];
            ty=y+dy[i];
            if(a[tx][ty]=='.' && tx>=0 && ty>=0 && tx<n && ty<m)	//判断条件
            {
                ans++;
                dfs(tx,ty);		//满足条件继续搜索
            }
        }
}
/*------------主要算法--------------*/
int main()
{
    cin>>m>>n;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>a[i][j];
            if(a[i][j]=='@')
            {
               x=i,y=j;
            }
        }
    }
    dfs(x,y);
    cout<<ans;
    return 0;
}

同时二分两个答案

/*a为第一个答案，b为第二个答案*/
int main()
{
    long long n,a,b,mid,l,r;
	cin>>n;
    int flag=0;
	long long t=sqrt((double)n*2);
	for (long long i=1;i<t;i++)
    {
		l=i;
		r=t;
        a=l*(l+1)/2;
		mid=l+r >>1;
		while (l<=r)	//持续二分的条件
        {
            b=mid*(mid+1)/2;
			if(a+b<n)
			{
				l=mid+1;
				mid=l+r >>1;
			}
			else if(a+b>n)
			{
				r=mid-1;
				mid=l+r >>1;
			}
			else
			{
				flag=1;
				break;
			}
		}
		if (flag==1)
			break;
	}
	if (flag==1)
		cout<<"YES"<<endl;
	else
		cout<<"NO"<<endl;
	return 0;
}

浮点单答案二分

int n,y;
double mid;
double anss()
{
    double t=0;
    for(int i=1;i<=n;i++)
        t+=(y/(pow(mid+1,i)));
    return t;
}
int main()
{
    int x;
    double l=0,r=11;	//左右端点
    double ans=0x3f3f3f;
    cin>>x>>y>>n;
    
/*------------主要算法--------------*/
    while(r-l>1e-6)		//持续二分的条件
    {
        mid=(l+r)/2;
        ans=anss();
        if(ans>x)l=mid;		//端点的处理(一般写一个返回bool的check函数进行检查)
        else r=mid;
    }
/*------------主要算法--------------*/
    
    printf("%.1f",l*100);
    return 0;
}