Question

我正在处理一个编码问题，并给出了一个数组，例如：[1、7、3、21、13、19]

我想将数组中的项目配对。然后，我想应用这个简单的规则。

说我选择一对x和y：

规则：

如果x> y：y = 2 * y和x = x-y
如果y> x：x = 2 * x和y = y-x
如果x == y：破坏＃x并且y是不会引起无限循环的对

示例：

说x = 7和y = 3

第一轮：x = 7，y = 3

第二轮：x = 4和y = 6

第三轮：x = 8，y = 2

第4轮：x = 6，y = 4

在这一点上，您知道这对将永远循环

例如，如果x = 1且y = 3

第一轮：x = 1，y = 3

第二轮：x = 2和y = 2

在这一点上，您知道这对不会循环

所以为了解决这个问题。我将其视为某种TSP，但不是最大化路径，而是最大化路径。

所以我要做的第一步是创建节点图并标记一对是否为循环

在此数组中，生成的图（邻接矩阵）是这样的：

0 0 0 1 1 1 
0 0 1 0 1 1 
0 1 0 0 0 1 
1 0 0 0 1 1 
1 1 0 1 0 0 
1 1 1 1 0 0

图中的索引表示数组中的索引。例如，假设我是行，而j是列。如果查看i = 0，则j = 2表示array [i] = x，array [j] = y，它是array [0] = x = 1，array [2] = y = 3。我们知道那不是循环。因此该索引的权重为0。

然后，我执行最近的邻居TSP算法（修改为最大路由），以获取使循环对数量最大化的最大对。该方法通过了除一个以外的编码测试用例。我无法确定会导致代码失败的整数数组。而且关于编码挑战的测试用例并没有提供有关失败的测试的任何信息。

这是我的代码：

import java.util.HashMap;
public class DistractTheGuards {

private static boolean IsPairLoop(int first, int second)
{
    long result = first + second;
    boolean success = true;
    while ((result & 1) == 0)
    {
        if (first == second)
        {
           success = false;
           break;
        }
        else if (first > second)
        {
            first = (first - second) / 2;
        }
        else
        {
            second = (second - first) / 2;
        }
        result = first + second;
    }
    return success;
}

public static void GenWeights(int[][] graph, int[] banana_list)
{
    for (int i = 0; i < graph.length; ++i)
    {
        for (int j = 0; j < graph.length; ++j)
        {
            if (IsPairLoop(banana_list[i], banana_list[j]))
            {
                graph[i][j] = 1;
            }
            else
            {
                graph[i][j] = 0;
            }
        }
    }
}

private static boolean AreAllNodesVisited(boolean[] visited)
{
    boolean all_visited = true;
    for (int i = 0; i < visited.length; ++i)
    {
        all_visited &= visited[i];
        if (!all_visited)
            break;
    }
    return all_visited;
}

private static int FindMaxTourKey(HashMap<Integer, int[]> tours)
{
    int cur_max_r = -1;
    for (Integer rank : tours.keySet())
    {
        if (cur_max_r < rank)
            cur_max_r = rank;
    }

    return cur_max_r;
}

private static int GetN(int[][] graph, int[] max_tour, int n)
{
    for (int i = 0; i < max_tour.length; i += 2)
    {
        if (i + 1 >= max_tour.length)
            break;
        if (graph[max_tour[i]][max_tour[i+1]] == 0)
        {
            n -= 2;
        }
    }
    return n;
}

public static int answer(int[] banana_list)
{
    int n = banana_list.length;

    if (n < 1)
        return 0;
    if (n == 1)
        return 1;

    int[][] graph = new int[n][n];
    GenWeights(graph, banana_list);
    HashMap<Integer, int[]> tours = new HashMap<>();

    for (int i = 0; i < n; ++i)
    {
        int[] cur_tour = new int[n];
        boolean[] visited = new boolean[n];
        int start_node = i;
        int cur_tour_i = 0;

        while (!AreAllNodesVisited(visited))
        {
            int s_n = start_node;
            visited[start_node] = true;
            cur_tour[cur_tour_i++] = start_node;
            int cur_max = 0;
            for (int j = 0; j < n; ++j)
            {
                if (!visited[j])
                {
                    if (cur_max < graph[start_node][j])
                    {
                        cur_max = graph[start_node][j];
                        start_node = j;
                        break;
                    }
                }
            }

            if (s_n == start_node)
            {
                for (int x = n - 1; x >= 0; --x)
                {
                    if (!visited[x])
                    {
                        start_node = x;
                        break;
                    }
                }
            }
        }

        int cur_tour_r = 0;
        for (int x = 0; x < n; x += 2)
        {
            if (x + 1 >= n)
                break;
            cur_tour_r += graph[cur_tour[x]][cur_tour[x+1]];
        }

        tours.put(cur_tour_r, cur_tour.clone());
        if (cur_tour_r == n - 1)
            break;
    }

    int cur_max_r = FindMaxTourKey(tours);

    if (tours.size() == 0)
        return 0;

    int[] max_tour = tours.get(cur_max_r);

    return GetN(graph, max_tour, n);
   }
}

我只需要帮助确定可能导致方法失败的边缘情况。谁能帮助我或给我一个肯定会使我的方法失败的数组？我可以从那里拿走。谢谢

更新

约束

1 <=整数<= 2 ^ 30
1 <= len（array）<= 100

如何确定失败代码的边缘情况？

0 个答案: