【LeetCode每日一题】——1042.不邻接植花

一【题目类别】

• 图

二【题目难度】

• 中等

三【题目编号】

• 1042.不邻接植花

四【题目描述】

• 有 n 个花园，按从 1 到 n 标记。另有数组 paths ，其中 paths[i] = [xi, yi] 描述了花园 xi 到花园 yi 的双向路径。在每个花园中，你打算种下四种花之一。
• 另外，所有花园 最多 有 3 条路径可以进入或离开.
• 你需要为每个花园选择一种花，使得通过路径相连的任何两个花园中的花的种类互不相同。
• 以数组形式返回 任一 可行的方案作为答案 answer，其中 answer[i] 为在第 (i+1) 个花园中种植的花的种类。花的种类用 1、2、3、4 表示。保证存在答案。

五【题目示例】

• 示例 1：
  输入：n = 3, paths = [[1,2],[2,3],[3,1]]
  输出：[1,2,3]
  解释：
  花园 1 和 2 花的种类不同。
  花园 2 和 3 花的种类不同。
  花园 3 和 1 花的种类不同。
  因此，[1,2,3] 是一个满足题意的答案。其他满足题意的答案有 [1,2,4]、[1,4,2] 和 [3,2,1]
• 示例 2：
  输入：n = 4, paths = [[1,2],[3,4]]
  输出：[1,2,1,2]
• 示例 3：
  输入：n = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
  输出：[1,2,3,4]

六【题目提示】

• $1<=n<=104$
• $0<=paths.length<=2\ast 104$
• $paths[i].length==2$
• $1<=xi,yi<=n$
• $xi!=yi$
• $每个花园最多有3条路径可以进入或离开$

七【解题思路】

• 建立无向图的关系，使用布尔类型的数组存放当前花色是否被使用过，遍历每个结点的邻接结点，把邻接结点的标志位的花色置为已经使用，每次遍历都找没有使用过的花色给当前的花园

八【时间频度】

• 时间复杂度：时间复杂度应该是$O(N+paths.length)$还是$O(N\ast 邻接结点的个数)$不太确定，如果是后者的话就没法计算

九【代码实现】

1. Java语言版

package Graph;

import java.util.*;

public class p1042_FlowerPlantingWithNoAdjacent {

    public static void main(String[] args) {
        int N = 3;
        int[][] paths = {
                {1, 2},
                {2, 3},
                {3, 1},
        };
        int[] res = gardenNoAdj(N, paths);
        System.out.println("res = " + Arrays.toString(res));
    }

    public static int[] gardenNoAdj(int N, int[][] paths) {
        // 初始化花园，使用map保存花园与其邻接花园的关系
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        // 有几个花园就生成几个HashMao
        for (int i = 0; i < N; i++) {
            graph.put(i, new HashSet<>());
        }
        // 生成每个花园的各边关系
        for (int[] path : paths) {
            int a = path[0] - 1;
            int b = path[1] - 1;
            graph.get(a).add(b);
            graph.get(b).add(a);
        }
        // 定义结果数组，有几个花园数组就多大
        int[] res = new int[N];
        for (int i = 0; i < N; i++) {
            // 使用一个boolean的数组，判断当前花园是否使用这种花
            boolean[] used = new boolean[5];
            // 查看当前花园每个邻接花园的状态
            for (int adj : graph.get(i)) {
                used[res[adj]] = true;
            }
            // 给当前花园染色，因为有四种花，所以从1开始，4结束
            for (int j = 1; j < 4; j++) {
                // 说明当前花园可以使用这种花，就把当前花园的花置为当前花
                if (!used[j]) {
                    res[i] = j;
                }
            }
        }
        return res;
    }

}

2. C语言版

#include<stdio.h>
#include<stdlib.h>
#include<stdint.h>

/*花园结构体*/
struct node
{
	int paths[4];
	int path_num;
	int color;
};

int* gardenNoAdj(int N, int** paths, int pathsSize, int* pathColSize, int* returnSize)
{
	if (N == 0)
	{
		*returnSize = 0;
		return NULL;
	}
	int *res = (int *)malloc(sizeof(int) * N);
	memset(res, 0, sizeof(int) * N);
	struct node *Nodes = (struct node *)malloc(sizeof(struct node) * N);
	/*构造邻接矩阵*/
	for (int i = 0; i < pathsSize; i++)
	{
		int start = paths[i][0] - 1;
		int end = paths[i][1] - 1;
		Nodes[start].paths[Nodes[start].path_num] = end;
		Nodes[start].path_num++;
		Nodes[end].paths[Nodes[end].path_num] = start;
		Nodes[end].path_num++;
	}
	/*填充颜色*/
	for (int i = 0; i < N; i++)
	{
		int set[4] = { 1,-1,-1,-1 };
		for (int path_i = 0; path_i < Nodes[i].path_num; path_i++)
		{
			int n_path = Nodes[i].paths[path_i];
			/*这个颜色不能有*/
			if (res[n_path] != 0)
			{
				set[res[n_path] - 1] = 0;
			}
		}
		/*上色*/
		for (int j = 0; j < 4; j++)
		{
			if (set[j] == -1)
			{
				res[i] = j + 1;
				break;
			}
		}
	}
	*returnSize = N;
	return res;
}

/*主函数省略*/

十【提交结果】

1. Java语言版
   
2. C语言版