Question

一个大政府组织在班加罗尔设立办事处。办公室是长方形的，所以它的所有楼层都在矩形。办公室的尺寸是X单位x Y单位。办公室的每个楼层都有很大的员工休息能力。一切员工的小屋是方形的。所以每层的面积分为X * Y舱，尺寸为1单位x 1单位。

参见示例图。

在上图中，

P表示员工可以将文件传递给对方

NP意味着员工无法将文件传递给对方

如上例所示，地板尺寸为4单位×5单位，地板上有4 * 5 = 20个舱室，1个单元x 1个单元舱。有些小屋很好相互依附，有些则没有。小屋相互连接，在这些小屋中传递文件非常容易。其他小木屋彼此没有很好地连接，这些小屋中的文件传递是不可能的。上图中显示了带有P和NP标签的舱室分别

因此（3,1）的舱室可以在（2,1），（1,1），（1,2），（2,2）和（4,2）处传递文件。这些所有附加部分累积形成一个完整的通过区域。因此，由于没有通行舱，整个楼层被划分为不同的P区域。

与上面的示例一样，我们有两个P区域，一个在左边，一个在右边。组织可以纠正NP区域的机舱位置，但它会造成一些成本，每个NP舱可能有不同的成本。事实上，没有使用纠正NP舱，因为他们的工作是非常不同的。组织关注的是连接各个P区域。如果将一些NP舱转换为P舱，则可以进行此操作。所以挑战性的任务该组织希望以最低的成本组织这些小屋。

左图表示舱室情况，无论是P还是NP。右图有一些写在每个舱室的价值，这是所需的成本整理地板上的小木屋。如图所示，每个P舱的成本为-1，这意味着组织这些舱无需任何费用。但对于每个NP舱都有一些积极的成本。在该示例中有四个P区域，所有P区域仅由一个舱室组成。挑战对于组织来说，要连接所有四个P区域（这也是最低成本）。

这可以通过各种方式完成;两种可能的方式如下 -

方法1的成本是10 + 10 + 10 = 30

方法2的成本仅为2

因此，如果我们组建成本为2的NP舱，它将连接所有四个不同的P舱。对于上面的例子，这是最低成本。您必须返回所有P舱可以相互连接的最低可能成本。

输出规格：

这是一个整数，指定所有P舱可以相互连接的最低可能成本

或

如果所有P舱已相互连接或没有P舱

，则返回0

我的代码： -

class Code {
    public int[][] array;

    boolean flag=true;
    int[][] a;
    int R;
    int C;
    int MAX=2147483647;
    LinkedList l=new LinkedList();


    void initialize() {
        R=array.length;
        C=array[0].length;
        a=new int[R][C];

        for(int i=0;i<R && flag;i++) {
            for(int j=0;j<C && flag;j++) {
                if(array[i][j]==-1) {
                    flag=false;
                }
            }
        }
    }

    void process() {
        int p=0,q=0;
        for(int i=R-1;i>=0;i--) {
            for(int j=C-1;j>=0;j--){
                if(array[i][j]==-1) {
                    p=i;
                    q=j;
                    array[i][j]=0;
                }
                a[i][j]=MAX;
            }
        }
        l.add(p);
        l.add(q);
        a[p][q]=0;
    }

    void solve() {
        int p=0,q=0;
        while(l.size()>0) {
            p=(int)l.removeFirst();
            q=(int)l.removeFirst();

            for(int i=p-1;i<=p+1;i++) {
                for(int j=q-1;j<=q+1;j++){
                    if(i>=0 && j>=0 && i<R && j<C && a[i][j]>a[p][q]+array[i][j]) {
                        a[i][j]=a[p][q]+array[i][j];
                        l.add(i);
                        l.add(j);
                    }
                }
            }
        }
    }

    public int minimumcost() {
        initialize();

        if(flag)
            return 0;

        process();
        solve();

        MAX=0;
        for(int i=0;i<R;i++) {
            for(int j=0;j<C;j++){
                if(array[i][j]==0 && a[i][j]>MAX)
                    MAX=a[i][j];
            }
        }

        return MAX;
    }
}

这里，array是给定的数组，minimumcost是返回答案的函数。在10个测试用例中，5个是正确的。我无法找到错误。

在我的代码中，我首先检查了是否有至少一个带有P的小屋。从任何一个PPI已经遍历所有方向（所有邻居）使用链接列表（此处用作队列）跟踪到达此单元的最小值。最后我找到了最大值。

Answer 1

public class CandidateCode 
{ 

  public static void main(String arg[])
  {
    System.out.println(minimumpossiblecost("-1@10@-1#10@2@10#-1@10@-1"));
  }
  public static int minimumpossiblecost(String input1)
  {
    String arr[]=input1.split("#");
    int c=arr[0].split("@").length;
    int r=arr.length;
    int intarr[][]= new int[r][];
    for(int i=0;i<r;i++)
    {
        intarr[i]= new int[c];
    }
    for(int i=0;i<arr.length;i++)
    {
        String row[]=arr[i].split("@");
        for(int j=0;j<row.length;j++)
        {
            intarr[i][j]=Integer.parseInt(row[j]);
        }
    }
    int temp=0;
    int ans=0;
    for(int i=0;i<r;i++)
    {
        for(int j=0;j<r;j++) 
        {

            temp=0;
            if(intarr[i][j]==-1)
           {
            if(i==0 && j==0)
            {
                temp=minDiff(intarr[i][j+1],intarr[i+1][j],intarr[i+1][j+1]);
                if(temp==intarr[i][j+1])
                    intarr[i][j+1]=-1;
                else if(temp==intarr[i+1][j])
                    intarr[i+1][j]=-1;
                else if(temp==intarr[i+1][j+1])
                    intarr[i+1][j+1]=-1;
                ans=ans+temp;


            }
            else if(i==0 && j>0 && j<c-1)
            {
                temp=minDiff(intarr[i][j-1],intarr[i][j+1],intarr[i+1][j],intarr[i+1][j-1],intarr[i+1][j+1]);
                if(temp==intarr[i][j-1])
                    intarr[i][j-1]=-1;
                else if(temp==intarr[i][j+1])
                    intarr[i][j+1]=-1;
                else if(temp==intarr[i+1][j])
                    intarr[i+1][j]=-1;
                else if(temp==intarr[i+1][j-1])
                    intarr[i+1][j-1]=-1;
                else if(temp==intarr[i+1][j])
                    intarr[i+1][j+1]=-1;
                ans=ans+temp;

            }
            else if(i==0 && j==c-1)
            {
                temp=minDiff(intarr[i+1][j],intarr[i][j-1],intarr[i+1][j-1]);
                if(temp==intarr[i+1][j])
                    intarr[i+1][j]=-1;
                else if(temp==intarr[i][j-1])
                    intarr[i][j-1]=-1;
                else if(temp==intarr[i+1][j-1])
                    intarr[i+1][j-1]=-1;
                ans=ans+temp;

            }
            else if(i>0 && i<r-1 && j==0)
            {
                temp=minDiff(intarr[i+1][j],intarr[i-1][j],intarr[i][j+1],intarr[i-1][j+1],intarr[i+1][j+1]);
                if(temp==intarr[i+1][j])
                    intarr[i+1][j]=-1;
                else if(temp==intarr[i-1][j])
                    intarr[i-1][j]=-1;
                else if(temp==intarr[i][j+1])
                    intarr[i][j+1]=-1;
                else if(temp==intarr[i-1][j+1])
                    intarr[i-1][j+1]=-1;
                else if(temp==intarr[i+1][j+1])
                    intarr[i+1][j+1]=-1;
                ans=ans+temp;

            }
            else if(i>0 && i<r-1 && j==c-1)
            {

            temp=minDiff(intarr[i][j],intarr[i+1][j],intarr[i][j-1],intarr[i-1][j],intarr[i-1][j-1],intarr[i+1][j-1]);
                if(temp==intarr[i][j])
                    intarr[i][j]=-1;
                else if(temp==intarr[i+1][j])
                    intarr[i+1][j]=-1;
                else if(temp==intarr[i][j-1])
                    intarr[i][j-1]=-1;
                else if(temp==intarr[i-1][j])
                    intarr[i-1][j]=-1;
                else if(temp==intarr[i-1][j-1])
                    intarr[i-1][j-1]=-1;
                else if(temp==intarr[i+1][j-1])
                    intarr[i+1][j-1]=-1;
                ans=ans+temp;

            }
            else if(i==r-1 && j==0)
            {
                temp=minDiff(intarr[i-1][j],intarr[i][j+1],intarr[i-1][j+1]);
                if(temp==intarr[i-1][j])
                    intarr[i-1][j]=-1;
                else if(temp==intarr[i][j+1])
                    intarr[i][j+1]=-1;
                else if(temp==intarr[i-1][j+1])
                    intarr[i-1][j+1]=-1;
                ans=ans+temp;
            }
            else if(i==r-1 && j>0 && j<c-1)
            {
                temp=minDiff(intarr[i-1][j],intarr[i][j-1],intarr[i][j+1],intarr[i-1][j-1],intarr[i-1][j+1]);
                if(temp==intarr[i-1][j])
                    intarr[i-1][j]=-1;
                else if(temp==intarr[i][j-1])
                    intarr[i][j-1]=-1;
                else if(temp==intarr[i][j+1])
                    intarr[i][j+1]=-1;
                else if(temp==intarr[i-1][j-1])
                    intarr[i-1][j-1]=-1;
                else if(temp==intarr[i-1][j+1])
                    intarr[i-1][j+1]=-1;
                ans=ans+temp;
            }
            else if(i==r-1 && j==c-1)
            {
                temp=minDiff(intarr[i][j-1],intarr[i-1][j],intarr[i-1][j-1]);
                if(temp==intarr[i][j-1])
                    intarr[i][j-1]=-1;
                else if(temp==intarr[i-1][j])
                    intarr[i-1][j]=-1;
                else if(temp==intarr[i-1][j-1])
                    intarr[i-1][j-1]=-1;
                ans=ans+temp;

            }
            else
            {
                temp=minDiff(intarr[i+1][j],intarr[i-1][j],intarr[i][j+1],intarr[i][j-1],intarr[i-1][j+1],intarr[i-1][j-1],intarr[i+1][j+1],intarr[i+1][j-1]);
                if(temp==intarr[i+1][j])
                    intarr[i+1][j]=-1;
                else if(temp==intarr[i-1][j])
                    intarr[i-1][j]=-1;
                else if(temp==intarr[i][j+1])
                    intarr[i][j+1]=-1;
                else if(temp==intarr[i][j-1])
                    intarr[i][j-1]=-1;
                else if(temp==intarr[i-1][j+1])
                    intarr[i-1][j+1]=-1;
                else if(temp==intarr[i-1][j-1])
                    intarr[i-1][j-1]=-1;
                else if(temp==intarr[i+1][j+1])
                    intarr[i+1][j+1]=-1;
                else if(temp==intarr[i+1][j-1])
                    intarr[i+1][j-1]=-1;
                ans=ans+temp;

            }
         }
        }

    }
    return ans;
  }
  static int minDiff(int ...x)
  {
    int flag=0,min=10000;
    for(int i=0;i<x.length;i++)
    {
        if(x[i]==-1)
        {
            flag=1;
            break;
        }

    }
    if(flag==1)
    return 0;
    else
    {
        for(int i=0;i<x.length;i++)
        {
            if(x[i]<min)
            {
                min=x[i];
            }

        }   
    }
    return min;
  }
}

Answer 2

我建议使用类似Dijkstra的方法：

创建一个union-find数据结构，其中包含每个P-cell的条目和所有NP-cell的列表。合并相邻P细胞的条目并按其成本对NP细胞进行分类。连同目前支付的费用，这是任何州的描述。将该初始状态放在有序列表中（按到目前为止支付的成本排序）。检查union-find是否只包含一个连接的组件。如果是这样，你就完成了。

如果没有，请按以下步骤操作：从列表中选择成本最低的状态。选择成本最低的NP单元格并将其从列表中删除。将此状态添加到状态列表中。创建此状态的副本，并在union-find结构中为所选单元格添加条目，并将其与每个相邻的P-cell（union-find结构中已存在的单元格）合并。更新状态的成本并将其插入有序列表中。继续，直到union-find结构中只剩下一个连接的组件。

这基本上是在状态图中找到最短路径。此图表可能呈指数级大，但您不必计算整个图表。作为优化，您可以检查是否已经存在要插入列表的任何新状态（例如，通过使用哈希集）。

连接一些舱室的最低成本

2 个答案: