USACO Starry Night 解题报告

最新推荐文章于 2019-07-28 07:35:33 发布
最新推荐文章于 2019-07-28 07:35:33 发布
阅读量689 收藏 1
点赞数
分类专栏： USACO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thestoryofsnow/article/details/39608993
版权 

USER: chen chen [thestor1]
TASK: starry
LANG: C++

Compiling...
Compile: OK

Executing...
   Test 1: TEST OK [0.008 secs, 3508 KB]
   Test 2: TEST OK [0.008 secs, 3508 KB]
   Test 3: TEST OK [0.011 secs, 3508 KB]
   Test 4: TEST OK [0.008 secs, 3508 KB]
   Test 5: TEST OK [0.016 secs, 3508 KB]

All tests OK.

Your program ('starry') produced all correct answers!  This is your
submission #3 for this problem.  Congratulations!

这道题我是用的是最直接的方法。用DFS得到每个cluster，然后之前所有的cluster都逐一比较。比较的时候也是8种形状逐一比较。当然，先比较star的个数是否一样，轮廓（长方形）是否一样。每个cluster还用一个set保存了里面所有的点。如果usaco支持unordered_set的话，说不定会更快些。标准答案比较的时候看着像是位操作啥的，应该比我的直观解法快特别多，也没看懂。

/* 
ID: thestor1 
LANG: C++ 
TASK: starry 
*/
#include <iostream>
#include <fstream>  
#include <cmath>  
#include <cstdio>  
#include <cstring>  
#include <climits>  
#include <cassert>  
#include <string>  
#include <vector>  
#include <set>
#include <map>  
#include <queue>  
#include <stack>  
#include <algorithm>
// #include <unordered_map>
// #include <unordered_set>

using namespace std;

const int MAXW = 100;

class Cluster {
public:
	char label;
	int H, W;
	int ll, lr, ul, ur;
	int size;
	// std::vector<pair<int, int> > ones;
	set<int> ones;

	Cluster()
	{
		H = W = ll = lr = ul = ur = -1;
		size = 0;
	}
};

bool isIn(int r, int c, int H, int W)
{
	return 0 <= r && r < H && 0 <= c && c < W;
}

inline int index(int r, int c)
{
	return r * MAXW + c;
}

void dfs(int r, int c, int H, int W, vector<std::vector<char> > &skymap, Cluster &cluster)
{
	if (cluster.ll < 0 || r < cluster.ll)
	{
		cluster.ll = r;
	}
	if (cluster.lr < 0 || c < cluster.lr)
	{
		cluster.lr = c;
	}
	if (r > cluster.ul)
	{
		cluster.ul = r;
	}
	if (c > cluster.ur)
	{
		cluster.ur = c;
	}

	skymap[r][c] = cluster.label;
	cluster.size++;
	// cluster.ones.push_back(make_pair(r, c));
	cluster.ones.insert(index(r, c));

	int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0}, dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
	for (int d = 0; d < 8; ++d)
	{
		int nr = r + dx[d], nc = c + dy[d];
		if (isIn(nr, nc, H, W) && skymap[nr][nc] == '1')
		{
			dfs(nr, nc, H, W, skymap, cluster);
		}
	}
}

bool isSame(const Cluster &c1, Cluster &c2, vector<std::vector<char> > &skymap)
{
	if (c1.size != c2.size)
	{
		return false;
	}
	
	if (c1.H == c2.H && c1.W == c2.W)
	{
		// up->down, left->right
		bool flag = true;
		
		for (int i1 = c1.ll, i2 = c2.ll; i1 <= c1.ul && i2 <= c2.ul; ++i1, ++i2)
		{
			for (int j1 = c1.lr, j2 = c2.lr; j1 <= c1.ur && j2 <= c2.ur; ++j1, ++j2)
			{
				if (c1.ones.count(index(i1, j1)) != c2.ones.count(index(i2, j2)))
				{
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				break;
			}
		}

		if (flag)
		{
			return true;
		}

		// up->down, right->left
		flag = true;
		for (int i1 = c1.ll, i2 = c2.ll; i1 <= c1.ul && i2 <= c2.ul; ++i1, ++i2)
		{
			for (int j1 = c1.lr, j2 = c2.ur; j1 <= c1.ur && j2 >= c2.lr; ++j1, --j2)
			{
				if (c1.ones.count(index(i1, j1)) != c2.ones.count(index(i2, j2)))
				{
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				break;
			}
		}

		if (flag)
		{
			return true;
		}

		// down->up, left->right
		flag = true;

		for (int i1 = c1.ll, i2 = c2.ul; i1 <= c1.ul && i2 >= c2.ll; ++i1, --i2)
		{
			for (int j1 = c1.lr, j2 = c2.lr; j1 <= c1.ur && j2 <= c2.ur; ++j1, ++j2)
			{
				if (c1.ones.count(index(i1, j1)) != c2.ones.count(index(i2, j2)))
				{
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				break;
			}
		}

		if (flag)
		{
			return true;
		}

		// down->up, right->left
		flag = true;
		for (int i1 = c1.ll, i2 = c2.ul; i1 <= c1.ul && i2 >= c2.ll; ++i1, --i2)
		{
			for (int j1 = c1.lr, j2 = c2.ur; j1 <= c1.ur && j2 >= c2.lr; ++j1, --j2)
			{
				if (c1.ones.count(index(i1, j1)) != c2.ones.count(index(i2, j2)))
				{
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				break;
			}
		}

		if (flag)
		{
			return true;
		}
	}

	if (c1.H == c2.W && c1.W == c2.H)
	{
		// left->right, down->up
		bool flag = true;

		for (int i1 = c1.ll, j2 = c2.lr; i1 <= c1.ul && j2 <= c2.ur; ++i1, ++j2)
		{
			for (int j1 = c1.lr, i2 = c2.ul; j1 <= c1.ur && i2 >= c2.ll; ++j1, --i2)
			{
				if (c1.ones.count(index(i1, j1)) != c2.ones.count(index(i2, j2)))
				{
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				break;
			}
		}

		if (flag)
		{
			return true;
		}

		// right->left, down->up
		flag = true;

		for (int i1 = c1.ll, j2 = c2.ur; i1 <= c1.ul && j2 >= c2.lr; ++i1, --j2)
		{
			for (int j1 = c1.lr, i2 = c2.ul; j1 <= c1.ur && i2 >= c2.ll; ++j1, --i2)
			{
				if (c1.ones.count(index(i1, j1)) != c2.ones.count(index(i2, j2)))
				{
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				break;
			}
		}

		if (flag)
		{
			return true;
		}

		// left->right, up->down
		flag = true;

		for (int i1 = c1.ll, j2 = c2.lr; i1 <= c1.ul && j2 <= c2.ur; ++i1, ++j2)
		{
			for (int j1 = c1.lr, i2 = c2.ll; j1 <= c1.ur && i2 <= c2.ul; ++j1, ++i2)
			{
				if (c1.ones.count(index(i1, j1)) != c2.ones.count(index(i2, j2)))
				{
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				break;
			}
		}

		if (flag)
		{
			return true;
		}

		// right->left, up->down
		flag = true;

		for (int i1 = c1.ll, j2 = c2.ur; i1 <= c1.ul && j2 >= c2.lr; ++i1, --j2)
		{
			for (int j1 = c1.lr, i2 = c2.ll; j1 <= c1.ur && i2 <= c2.ul; ++j1, ++i2)
			{
				if (c1.ones.count(index(i1, j1)) != c2.ones.count(index(i2, j2)))
				{
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				break;
			}
		}

		if (flag)
		{
			return true;
		}
	}

	return false;
}

void repaint(vector<std::vector<char> > &skymap, char label, Cluster &cluster)
{
	for (int r = cluster.ll; r <= cluster.ul; ++r)
	{
		for (int c = cluster.lr; c <= cluster.ur; ++c)
		{
			if (skymap[r][c] == label)
			{
				skymap[r][c] = cluster.label;
			}
		}
	}
}

int main()
{
	ifstream fin("starry.in");
	ofstream fout("starry.out");

	int W, H;
	fin>>W>>H;
	std::vector<std::vector<char> > skymap(H, std::vector<char>(W, '0'));
	std::vector<Cluster> clusters;
	for (int r = 0; r < H; ++r)
	{
		string row;
		fin>>row;
		for (int c = 0; c < W; ++c)
		{
			if (row[c] == '1')
			{
				skymap[r][c] = '1';
			}
		}
	}

	char label = 'a';
	for (int r = 0; r < H; ++r)
	{
		for (int c = 0; c < W; ++c)
		{
			if (skymap[r][c] == '1')
			{
				Cluster cluster;
				cluster.label = label;
				dfs(r, c, H, W, skymap, cluster);
				// sort(cluster.ones.begin(), cluster.ones.end());
				cluster.H = cluster.ul - cluster.ll + 1;
				cluster.W = cluster.ur - cluster.lr + 1;

				bool unique = true;
				for (int i = 0; i < clusters.size(); ++i)
				{
					if (isSame(clusters[i], cluster, skymap))
					{
						unique = false;
						cluster.label = clusters[i].label;
						repaint(skymap, label, cluster);
						break;
					}
				}

				if (unique)
				{
					// cluster.label = label;
					clusters.push_back(cluster);
					// paint(skymap, cluster);
					label++;
				}
			}
		}
	}

	for (int r = 0; r < H; ++r)
	{
		for (int c = 0; c < W; ++c)
		{
			fout<<skymap[r][c];
		}
		fout<<endl;
	}

	fin.close();
	fout.close();
	return 0;  
}


thestoryofsnow
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
USACO5.1.2 Starry Night(starry)
xsy_victory的专栏
02-04 380
数据不大，但细节要注意。这道题的基本方法就是Floodfill，找到所有的连通块，把全等的连通块标识起来。 寻找全等连通块的方法很多，我的方法是把每个连通块散列存储起来。找到一个新的连通块的时候把它和旋转对称变换所得8个图形分别进行散列，然后在哈希表中查找是否出现过。如果出现过，新的连通块与以前的全等。如果没有出现，则找到了一个新的连通块，标识并存储即可。 /* PROB: starr
USACO 5.1 Starry Night（模拟）
dingdi3021的博客
03-25 98
2015-03-2522:14:58 思路：大模拟... 首先用floodfill判出每一个连通块，然后就是暴力枚举每个块的8个状态了... 写的超级暴力... 　　一开始MLE，把数组从int改到bool过了。后来TLE，加了一个剪枝（如果两个连通块内1的个数不等直接确定不一致）就过了。 　　关于8个状态：初始状态旋转 0°、90°、180°、270° 　　（overturn...
Starry Night [USACO]
weixin_30900589的博客
07-28 130
这道题目也比较简单，先想好怎么写，稍微写写伪代码，之后实现了即可。 /* ID: zhangyc1 LANG: C++ TASK: starry */ #include <string> #include <cstring> #include <cstdlib> #include <cstdio> using names...
[USACO5.1]夜空繁星Starry Night
weixin_33998125的博客
05-28 101
这个世界上怎么会有这么多恶心人的搜索啊 做法... 找联通块，找完之后尝试赋颜色 判重很玄学，算联通块上点的两两距离，求和。如果和一样，那么图形一定一样 然后就苦逼搜索就行了 1.0h #include<cstdio> #include<cstring> #include<algorithm> #include<queue> ...
usaco Starry Night
weixin_30701575的博客
10-05 79
就是最简单能想到的那种拿到两个形状然后匹配。 但是有好多好多 /* ID: modengd1 PROG: starry LANG: C++ */ #include <iostream> #include <stdio.h> #include <memory.h> #include <vector> using namespac...
USACO(Train)解题报告.doc
07-04
【USACO解题报告概述】 USACO（美国计算机奥林匹克竞赛）是一场面向中学生的在线编程比赛，旨在提升参赛者的算法设计和编程能力。这份解题报告涵盖了98道USACO题目，包含了多种算法和策略的应用。下面将详细讨论...
usaco2.1解题报告1
08-03
图论和种子染色法在 USACO 解题报告中的应用 在今天的解题报告中，我们将讨论图论和种子染色法在 USACO 解题报告中的应用，具体来说是解决一个名为 “castle” 的问题。这个问题来自 USACO 的比赛，要求我们计算一...
usaco2.4解题报告1
最新发布
08-04
usaco2.4解题报告1
usaco1.3解题报告1
08-04
usaco1.3解题报告1
usaco2.3解题报告1
08-03
usaco2.3解题报告1
USACO 5.1 Starry Night
weixin_30915951的博客
02-05 136
Starry NightIOI 98 High up in the night sky, the shining stars appear in clusters of various shapes. Aclusteris a non-empty group of neighbouring stars, adjacent in horizontal, vertical or dia...
usaco 5.1 Starry Night（BFS+枚举）
志当存高远
09-21 1338
Starry Night IOI 98 High up in the night sky, the shining stars appear in clusters of various shapes. A cluster is a non-empty group of neighbouring stars, adjacent in horizontal, vertical or diagon
Starry Night_usaco 5.1_bfs+暴力
olahiuj的博客
12-02 655
Description　　高高的星空，簇簇闪耀的群星形态万千。一个星座(cluster)是一群连通的星组成的非空集合，所谓连通是指水平，垂直或者对角相邻。一个星座不能是另一个更大星座的一部分。星座可以相似(similar)。如果两个星座有相同的形状，而且包括相同数目的星体，那么不管其方向性如何，就算相似。一般而言，星座可能的方向有八个，如图1所示。 图1 相似的八个星座Input夜空可以表
usaco5.1.2 Starry Night
max_kibble的博客
05-02 510
一 原题 Starry Night IOI 98 High up in the night sky, the shining stars appear in clusters ofvarious shapes. A cluster is a non-empty group of neighbouringstars, adjacent in horizontal, vertical
USACO Wormholes 解题报告
thestoryofsnow的专栏
10-06 4650
新加的USACO题都有youtube讲解，感觉非常好。由于section的位置和数据的规模（~12），可以知道就用
USACO Combination Lock 解题报告
thestoryofsnow的专栏
10-04 1878
新加的一道题，标准答案为suo'you
USACO Ski Course Design 解题报告
thestoryofsnow的专栏
10-06 1624
这里用的是naive的方法，测试suo
USACO Telecowmunication 解题报告
thestoryofsnow的专栏
10-16 1058
这道题没有首先想到是最大流问题，还yi'wei
USACO Twofive 解题报告
thestoryofsnow的专栏
10-26 1037
刚开始觉得用trie记录，后来发现根本不需要。d
USACO月赛题解1
08-03
"USACO月赛题解1包含了从2002年至2008年的解题报告，涉及多种算法，如并查集、BFS、IDA*等，涵盖了图论、数学、动态规划等多个IT领域的知识点。" 1. **并查集**： 在" Fiber Communications"问题中，利用并查集来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值