蚂蚁问题-POJ1852-P1367--思维题--详解--Sabrinadol--Sabrina

POJ1852
蚂蚁
时间限制： 1000MS 内存限制： 30000K
提交总数： 31489 接受： 11801
描述

一队蚂蚁在长度为1厘米的水平杆上行走，每根杆的速度恒定为1厘米/秒。当一只行走的蚂蚁到达极的一端时，它会立即从它上掉下来。当两只蚂蚁相遇时，它们会转身并开始向相反方向行走。我们知道蚂蚁在杆子上的原始位置，不幸的是，我们不知道蚂蚁行走的方向。你的任务是计算所有蚂蚁从杆上掉下来所需的最早和最晚时间。
输入

第一行输入包含一个整数，给出后面的案例数。每种情况的数据都以两个整数开始：极点长度（cm）和n，极点上的蚂蚁数量。这两个数字之后是n个整数，它们将杆上每只蚂蚁的位置作为从杆的左端测量的距离，没有特别的顺序。所有输入整数都不大于1000000，它们由空格分隔。
产量

对于每种输入情况，输出由单个空格分隔的两个数字。第一个数字是所有蚂蚁从杆上掉下来的最早时间（如果他们的步行方向选择得恰当），第二个数字是最久可能的时间。
样本输入

2
10 3
2 6 7
214 7
11 12 7 13 176 23 191
样本输出

4 8
38 207
资源

滑铁卢当地人2004.09.19

题解

1.算法思想
我们·来看本题，直接对结果进行分析，是不是可以知道每个蚂蚁的最终的结果都是落了下来。其次题目中提到了，在两只蚂蚁相遇的过程中，两只蚂蚁会反向，首先我们的想法就是直接枚举，但是这样的时间复杂度显然是 2^n,不用想就要舍弃。既然是求最值，那么肯定跟贪心什么的有关系。回到蚂蚁反向的时刻，虽然蚂蚁反向了，但是两只蚂蚁的最终结果难道不都是掉下去了吗，并且两只蚂蚁并没有任何区别，那么我们可不可以看做两只蚂蚁并未反向，而是进行了灵魂交换。。。？
想到这里问题就很明朗了，通过贪心的策略，对于每一只蚂蚁而言，最长时间就是朝向离自己最远的一端，最近时间就是朝向离自己最近的一端。
直接套上一个循环然后求最值即可；
2.核心代码讲解

int lmi=0,lmx=0;
		for(int i=1;i<=m;i++)
		{
			lmi=max(lmi,min(a[i],n-a[i]));
			//动态求最小值
			//因为是时间，所以要满足时间最长的蚂蚁能够掉下去，所以要在原最小值和现最小值间取最大值
			lmx=max(lmx,max(a[i],n-a[i]));
			//同理
		}
		cout<<lmi<<" "<<lmx<<endl;

3.附上AC代码

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#define maxn 1000005
using namespace std;
int t;
int a[maxn];
int n,m; 
int main()
{
	cin>>t;
	while(t--)
	{
		cin>>n>>m;
		for(int i=1;i<=m;i++)
			cin>>a[i];
		int lmi=0,lmx=0;
		for(int i=1;i<=m;i++)
		{
			lmi=max(lmi,min(a[i],n-a[i]));
			lmx=max(lmx,max(a[i],n-a[i]));
		}
		cout<<lmi<<" "<<lmx<<endl;
	}
	while(1)
	cout<<"Sabrina"<<endl;//防copy
	return 0;
}

P1367
题目描述
有许多蚂蚁在一根无限长的木棍上，每一只蚂蚁都有一个初始位置和初始朝向（任意两只蚂蚁的初始位置不同）。蚂蚁们以每秒一个单位的速度向前移动，当两只蚂蚁相遇时，它们会掉头（掉头时间忽略不计）。现给出每只蚂蚁的初始位置和初始朝向，请你计算出它们在t秒后的位置和朝向。

输入格式
第一行，两个空格隔开的整数n，t（代表蚂蚁数n和时间t）

第2~n+1行每行两个整数，第i+1行代表第i只蚂蚁的初始位置ai（ai的绝对值在1000000以内）及初始朝向bi（bi=1时蚂蚁朝右，bi=-1时蚂蚁朝左）

输出格式
n行，每行两个整数，第i行代表t秒后第i只蚂蚁的位置及朝向（-1表示朝左，1表示朝右，0表示正在转向中）

输入输出样例
输入 #1 复制
4 1
1 1
5 1
3 -1
10 1
输出 #1 复制
2 0
6 1
2 0
11 1
说明/提示
【数据范围】

对于40%的数据，n<=100

对于80%的数据，n<=10000,t<=1000

对于100%的数据，n<=100000,t<=100000

题解

1.算法思想
此题相对而言就要稍微复杂一些，可以称其为升级版。

整体思路

看到本题，很明显，经过上一道题的练习，我们很容易想到只管初末状态，在更换灵魂的时候只需要换一下数组下标，最后直接输出就好

具体实现

因为关于一个下标，我们有两个数据（方向，位置）来存储，所以显然需要开一个结构体。
其次，因为要把时间复杂度控制在线性上面，所以显然需要预处理，也就是按输入的位置来排序
2.
其次，我们需要另开一个结构体数组来存贮之后的状态
3.
在对下标的处理中，我们需要另开一个数组来改变下标对蚂蚁的映射关系，使输出的序列满足从小到大
4.可能有人还比较模糊，看代码
5.附上AC代码

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#define maxn 10005
using namespace std;
struct node{
	int s;//存位置
	int h;//存方向
	int num;//存下标
}q[maxn],p[maxn];//q用来保存初状态，p用来保存末状态
bool cmp(node x,node y)
{
	return x.s<y.s;
} 
int n,t;
int a,b;	
int order[maxn];//改变的映射关系
int main()
{
	cin>>n>>t;
	for(int i=1;i<=n;i++)
	{
		cin>>a>>b;
		q[i].s=a;
		q[i].h=b;
		q[i].num=i;
		p[i].s=a+b*t;//t的正负代表了向右还是向左
		p[i].num=0;//对于p数组是用来通过order的映射输出的所以不需要
		p[i].h=b;
	}
	sort(q+1,q+1+n,cmp);//预处理

	for(int i=1;i<=n;i++)
	{
		order[q[i].num]=i;//从左到右的蚂蚁编号映射成现在sort后对应的下标
	}
	sort(p+1,p+1+n,cmp);//同样，将蚂蚁按从左到右排列
	for(int i=1;i<=n;i++)
	{
		if(p[i].s==p[i+1].s)//这个是用来考虑判断是否正在经历相遇转向的过程
		{
			p[i].h=0;
			p[i+1].h=0;
		}
	}
	for(int i=1;i<=n;i++)
	{
		int g=order[i];
		//再通过映射关系，获得根据输入数据而获得的标号，实现相遇时的反向，交换，下面有一波打表
		//大概就是说第i个输入的数现在在第几个位置上 
		cout<<p[g].s<<" "<<p[g].h<<endl;
	} 
	return 0;
}

n=3； t=2；
q[1].s=3;q[1].num=1;q[1].h=-1;
q[2].s=2;q[2].num=2;q[1].h=1;
q[3].s=1;q[3].num=3;q[3].h=1;
p[1].s=1;p[1].h=-1;
p[2].s=4;p[2].h=1;
p[3].s=3;p[3].h=1;
sort1:
q[1].num=3;q[2].num=2;q[3].num=1;

order[1]=3;order[2]=2;order[3]=1;

sort2:
p[1].s=1;p[2].s=3;p[3].s=4;

for:
i=1:g=3;
i=2:g=2;
i=3:g=1;