• poj_2286 线段树


    题目大意

        在墙上贴海报,墙壁是由一排连续的瓷砖铺成,海报贴在墙壁上必须占据连续的几块瓷砖,海报可以互相覆盖,问最后可以看见几张海报(未被完全覆盖)。

    题目分析

        墙壁是由连续的一个区间构成,每个海报占据几块瓷砖,即占据一个区间。每次进行贴海报,是进行区间操作,而最后查询有多少个海报可见也是对区间进行查询。对区间进行操作,考虑使用线段树

        由于瓷砖数目太大 100000000,直接进行构建线段树会超内存,也会超时。因此需要进行离散化之后再使用线段树: 
        当所有的海报都铺完毕之后,会将墙壁分割成多个连续的区间(由海报的左右两边作为边界),这些区间长度不固定,但是将他们视为相同的一个单元并不影响结果,因此将所有的瓷砖离散化为 这些由海报的边缘分割出来的单元。 
        当张贴海报p的时候,确定该海报占据离散化之后的那些单元区间,然后将该区间标记为海报p;之后再次贴海报p1时,覆盖了海报p的一部分,需要更新之前p覆盖的单元的标记。由于线段树的特点,可以在标记的时候延迟标记。 
        张贴完所有海报之后,进行查询。从线段树的根节点开始递归查询,看节点代表的区间被那个海报完全覆盖。这样可以确定有哪些海报最终可见。

    实现(c++)

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<vector>
    #include<string.h>
    #include<algorithm>
    using namespace std;
    
    #define MAX_POSTER_NUM 10001			 //海报最多张数
    #define MAX_SEG_NUM 2*MAX_POSTER_NUM	 //由海报边缘确定的最多的分段数
    #define MAX_NODE_NUM 4*MAX_SEG_NUM		 //线段树的节点最多
    
    #define MIN(a, b) a < b? a : b
    #define MAX(a, b) a > b? a : b
    struct Node{
    	int left;				//该节点代表的离散化之后区间的起始点序号
    	int right;				//该节点代表的离散化之后区间的终止点序号
    	int beg_byte;			//该节点代表离散化之后的区间起始点  代表的起始瓷砖号
    	int end_byte;			//该节点代表离散化之后的区间终止点  代表的终止瓷砖号
    	int top_cover_num;		//该节点代表的离散化之后区间被 那块海报完全覆盖,没被任何瓷砖完全覆盖则为-1
    };
    Node gNodes[MAX_NODE_NUM];
    
    struct Poster{
    	int left;			//海报占据瓷砖区间的开始
    	int right;			//海报占据瓷砖区间的结束
    };
    
    struct SegUnit{
    	int beg;			//离散化之后的区间 的起始瓷砖号
    	int end;			//离散化之后的区间 的终止瓷砖号
    };
    SegUnit gSegUnit[MAX_SEG_NUM];
    Poster gPosters[MAX_POSTER_NUM];
    int gSegUnitNum;		//离散化之后的总区间数目
    
    vector<int> gPartPoint;	//用于离散化区间
    int gVisibleCount[MAX_POSTER_NUM];	//判断海报是否可见
    
    //构建线段树, left, right 为离散化之后区间的起始和结束; index为线段树节点编号
    void BuildSegTree(int left, int right, int index){
    	gNodes[index].left = left;
    	gNodes[index].right = right;
    	gNodes[index].top_cover_num = -1;
    	if (left == right){
    		gNodes[index].beg_byte = gSegUnit[left].beg;
    		gNodes[index].end_byte = gSegUnit[left].end;
    		return;
    	}
    	int left_child = 2 * index + 1, right_child = 2 * index + 2;
    	int mid = (left + right) / 2;
    	BuildSegTree(left, mid, left_child);
    	BuildSegTree(mid + 1, right, right_child);
    
    	//父节点的起始和结束的瓷砖编号由 左右子节点决定
    	gNodes[index].beg_byte = gNodes[left_child].beg_byte;
    	gNodes[index].end_byte = gNodes[right_child].end_byte;
    }
    
    //离散化
    void InitSegUnit(){
    	gSegUnitNum = 0;
    	for (int i = 0; i < gPartPoint.size() - 1; i++){		
    			gSegUnit[gSegUnitNum].beg = gPartPoint[i];
    			gSegUnit[gSegUnitNum].end = gPartPoint[i + 1];
    			gSegUnitNum++;
    
    	}
    }
    //更新,节点index 之前被某张海报完全覆盖,现在又有新的海报完全或者部分覆盖index。则将index的top_cover_num 更新
    void PushDown(int index){
    	int left_child = 2 * index + 1;
    	int right_child = 2 * index + 2;
    	gNodes[left_child].top_cover_num = gNodes[index].top_cover_num;
    	gNodes[right_child].top_cover_num = gNodes[index].top_cover_num;
    }
    
    
    //贴海报
    void Post(int poster_num, int poster_beg, int poster_end, int index){
    	if (gNodes[index].beg_byte >= poster_beg && gNodes[index].end_byte <= poster_end){
    		gNodes[index].top_cover_num = poster_num;
    		return;
    	}
    	else if (gNodes[index].beg_byte > poster_end || gNodes[index].end_byte < poster_beg){
    		return;
    	}
    	if (poster_beg >= poster_end){
    		return;
    	}
    	int left_child = 2 * index + 1, right_child = 2 * index + 2;
    	int left_beg = gNodes[left_child].beg_byte, left_end = gNodes[left_child].end_byte,
    		right_beg = gNodes[right_child].beg_byte, right_end = gNodes[right_child].end_byte;
    
    	if (gNodes[index].top_cover_num != -1){
    		PushDown(index);
    		gNodes[index].top_cover_num = -1;
    	}
    	
    	Post(poster_num, poster_beg, MIN(left_end, poster_end), left_child);
    	Post(poster_num, MAX(right_beg, poster_beg), poster_end, right_child);
    }
    
    //统计有多少海报是可见的
    void CalVisibleSeg(int index){
    	if (gNodes[index].top_cover_num != -1){
    		gVisibleCount[gNodes[index].top_cover_num] = 1;
    		return;
    	}
    	
    	if (gNodes[index].left == gNodes[index].right){
    		return;
    	}
    	
    	int left_child = 2 * index + 1;
    	int right_child = 2 * index + 2;
    	CalVisibleSeg(left_child);
    	CalVisibleSeg(right_child);
    }
    
    void debug(int index){
    	
    	printf("index  = %d, left = %d, right = %d, beg_byte = %d, end_byte = %d, top_num = %d
    ", index, gNodes[index].left,
    		gNodes[index].right, gNodes[index].beg_byte, gNodes[index].end_byte, gNodes[index].top_cover_num);
    
    	if (gNodes[index].left == gNodes[index].right){
    		return;
    	}
    
    	int left = 2 * index + 1;
    	int right = 2 * index + 2;
    	debug(left);
    	debug(right);
    }
    int main(){
    	int cas, poster_num;
    	scanf("%d", &cas);
    	while (cas--){
    		scanf("%d", &poster_num);
    		gPartPoint.clear();
    		gPartPoint.reserve(poster_num * 2);
    		memset(gVisibleCount, 0, sizeof(gVisibleCount));
    
    		for (int i = 0; i < poster_num; i++){
    			scanf("%d %d", &gPosters[i].left, &gPosters[i].right);
    			gPosters[i].right++;		// 将闭区间转换为开区间 [i, j] 覆盖i,i+1, ..j 瓷砖,
    										//转换为 [i, j +1), 也表示覆盖 i,i+1, ..j 瓷砖
    
    			gPartPoint.push_back(gPosters[i].left);
    			gPartPoint.push_back(gPosters[i].right);
    		}
    		//离散化
    		sort(gPartPoint.begin(), gPartPoint.end());
    		vector<int>::iterator it = unique(gPartPoint.begin(), gPartPoint.end());
    		gPartPoint.erase(it, gPartPoint.end());
    		InitSegUnit();
    		BuildSegTree(0, gSegUnitNum - 1, 0);
    		for (int i = 0; i < poster_num; i++){
    			Post(i, gPosters[i].left, gPosters[i].right, 0);
    		}
    		CalVisibleSeg(0);
    		int result = 0;
    		for (int i = 0; i < poster_num; i++){
    			result += gVisibleCount[i];
    		}
    		printf("%d
    ", result);
    	}
    	return 0;
    }
    
  • 相关阅读:
    hdu 2147 kiki's game
    HDU 1846 Brave Game
    NYOJ 239 月老的难题
    NYOJ 170 网络的可靠性
    NYOJ 120 校园网络
    xtu字符串 B. Power Strings
    xtu字符串 A. Babelfish
    图论trainning-part-1 D. Going in Cycle!!
    XTU 二分图和网络流 练习题 J. Drainage Ditches
    XTU 二分图和网络流 练习题 B. Uncle Tom's Inherited Land*
  • 原文地址:https://www.cnblogs.com/gtarcoder/p/4783636.html
Copyright © 2020-2023  润新知