Java 连接一些舱室的最低成本

一个大型政府组织在班加罗尔设立了办事处。这间办公室是长方形的，所以它的所有楼层也都是长方形的 长方形。办公室的尺寸是X单位X Y单位。办公室的每一层都有很大的员工坐位。所有的 员工的小屋是方形的。因此，每个楼层的面积被划分为尺寸为1个单元X 1个单元的X*Y隔间

请参见示例中给出的图表

在上图中

p表示员工可以互相传递他们的文件

NP意味着员工不能互相传递他们的文件

如上述示例所示，地板尺寸为4个单元x 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;
    }
}

类代码{
公共int[][]数组；
布尔标志=真；
int[]a；
INTR；
INTC；
int MAX=2147483647；
LinkedList l=新建LinkedList（）；
void initialize（）{
R=数组长度；
C=数组[0]。长度；
a=新整数[R][C]；
对于（int i=0；i=0；j--）{
if（数组[i][j]=-1）{
p=i；
q=j；
数组[i][j]=0；
}
a[i][j]=最大值；
}
}
l、 加（p）；
l、 加（q）；
a[p][q]=0；
}
void solve（）{
int p=0，q=0；
而（l.size（）>0）{
p=（int）l.removeFirst（）；
q=（int）l.removeFirst（）；
对于（int i=p-1；i=0&&i，我建议采用类似Dijkstra的方法：

创建一个union find数据结构，其中包含每个p单元的条目和所有NP单元的列表。合并相邻p单元的条目并按成本对NP单元进行排序。连同迄今为止支付的成本，这是对任何状态的描述。将该初始状态放在有序列表中（按迄今为止支付的成本排序）。检查联合查找是否只包含一个连接的组件。如果是，则完成

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

这基本上是在状态图中查找最短路径。此图可能是指数级的，但您不必计算整个图。作为优化，您可以检查要插入列表中的任何新状态是否已经存在（例如，通过使用哈希集）。
公共类候选代码
{ 
公共静态void main（字符串arg[]）
{
系统输出打印项次（最小可能成本（“-1@10@-1#10@2@10#-1@10@-1"));
}
公共静态int最小可能成本（字符串输入1）
{
字符串arr[]=input1.split（“#”）；
int c=arr[0]。拆分（“@”）。长度；
int r=阵列长度；
int intarr[][]=新int[r][]；
for（inti=0；iSo为什么这个Q得到了负面评价，但没有人对此发表评论？帮助这个家伙理解他做错了什么；-）为了让我们了解你的代码有问题，你的整个家庭作业真的有必要吗？你发布了一些代码，这是你的道具，但这个问题是懒散地放在一起的。你需要考虑到实际阅读这篇文章的人，并在simpli上投入更多的精力
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;
  }
}