BNUOJ 26182 -----------Army Buddies 用结构体仿双向链表的简单操作

最新推荐文章于 2016-06-14 09:27:43 发布

原创最新推荐文章于 2016-06-14 09:27:43 发布 · 2.7k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#each #report #character #output #input

oj_data structure 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一种用于模拟战争中线性部队阵型变化的算法。该算法通过建立士兵间的链表结构来高效处理士兵伤亡导致的阵型变动，确保算法在大规模数据下也能快速响应。

Nlogonia is fighting a ruthless war against the neighboring country of Cubiconia. The Chief General of Nlogonia's Army decided to attack the enemy with a linear formation of soldiers, that would advance together until conquering the neighboring country. Before the battle, the Chief General ordered that each soldier in the attack line, besides protecting himself and attacking, should also protect his two (nearest) neighbors in the line, one to his left and one to his right. The Chief General told the soldiers that for each of them, his ``buddies" would be these two neighbors, if such neighbors existed (because the leftmost soldier does not have a left neighbor and the rightmost soldier does not have a right neighbor). The Chief General also told the soldiers that protecting their buddies was very important to prevent the attack line from being broken. So important that, if the left or right buddy of a soldier is killed, then the next living neighbor to the left or to the right of the soldier, respectively, should become his buddy.

The battle is fierce, and many soldiers in the attack line are being killed by fire shots, grenades and bombs. But following the Chief General's orders, immediately after knowing about losses in the attack line, the Army's information systems division has to inform the soldiers who their new buddies are.

You are given the number of soldiers in the attack line, and a sequence of loss reports. Each loss report describes a group of contiguous soldiers in the attack line that were just killed in the battle. Write a program that, for each loss report, prints the new buddies formed.

Input

Each test case is described using several lines. The first input line contains two integers S and B representing respectively the number of soldiers in the attack line, and the number of loss reports (1 $\le$ B $\le$ S $\le$ 10⁵). Soldiers are identified by different integers from 1 to S, according to their positions in the attack line, being 1 the leftmost soldier and S the rightmost soldier. Each of the next B input lines describes a loss report using two integers L (left) and R (right), meaning that soldiers from L to R were killed (1 $\le$ L $\le$ R $\le$ S). You may assume that until that moment those soldiers were alive and were just killed.

The last test case is followed by a line containing two zeros.

Output

For each test case output B + 1 lines. In the i-th output line write the new buddies formed by removing from the attack line the soldiers that were just killed according to the i-th loss report. That is, for the loss report `L R', print the first surviving soldier to the left of L, and the first surviving soldier to the right of R. For each direction, print the character `*' (asterisk) if there is no surviving soldier in that direction. Print a line containing a single character `-' (hyphen) after each test case.

Sample Input

Sample Output

* *
-
1 6
1 10
* 10
* *
-
* 2
-

常规的遍历方法会超时

运用链表的思想建立一个结构体

结构体里面有两个元素，分别指向士兵的左兄弟与右兄弟的编号

有士兵死亡一次，就改变死亡士兵边上的士兵的结构体中记录的编号这相当于代替了指针，因为不会指针囧TZ~

这样每次有死亡就更新，相当于链表的断开与再连接！

假如左边是0或右边是S+1,就是没人了，输出 * 即可

代码：

#include <iostream>
#include <cstdio>
using namespace std;

typedef struct node
{
	int front;
	int next;
};

int main()
{
	int S,B;
	while(cin>>S>>B&&(S+B)!=0)
	{
		node a[S+2];
		for(int i=1;i<=S;i++)
		{
			a[i].front=i-1;
			a[i].next=i+1;	
		} 
		while(B--)
		{
			int x,y;
			scanf("%d%d",&x,&y);
			a[a[x].front].next=a[y].next;
			a[a[y].next].front=a[x].front;
			if(a[x].front==0)
				printf("*");
			else
				printf("%d",a[x].front);
			printf(" ");
			if(a[y].next==S+1)
				printf("*");
			else
				printf("%d",a[y].next);
			printf("\n");
		}
		cout<<"-"<<endl;
	}
	return 0;
}