Java 城市间最大不重叠桥梁的算法

河的两边都有相同数量的城市。一座桥从一侧的城市到另一侧的城市，由

1#y3

表示，其中位于下侧的城市1与位于上侧的城市3之间有一座桥。我们必须找到非重叠桥梁的最大数量。因此，对于输入

1#y2，2#y4，3#y1，4#y5，5#y3，6#y6

out将是

4

，因为

1#y2，2#y4，4#y5，6

是不重叠的

这是我的密码-

public static int maxNonOverlappingBridges(String input1[]) {
    int result = 0;
    for (int i = 0; i < input1.length; i++) {
        int total = 1;
        int notCrossing = Integer.parseInt(input1[i].substring(input1[i].length() - 1));
        for (int j = 0; j < input1.length; j++) {
            if (j < i) {
                if (Integer.parseInt(input1[j].substring(input1[j].length() - 1)) < notCrossing) {
                    total += 1;
                    notCrossing = Integer.parseInt(input1[j].substring(input1[j].length() - 1));
                }
            } else if (j > i) {
                if (Integer.parseInt(input1[j].substring(input1[j].length() - 1)) > notCrossing) {
                    total += 1;
                    notCrossing = Integer.parseInt(input1[j].substring(input1[j].length() - 1));
                }
            } else {
                notCrossing = Integer.parseInt(input1[j].substring(input1[j].length() - 1));
            }

        }
        if (total > result) result = total;
    }
    return result;
}

public static int maxNonOverlappingBridges（字符串input1[]）{
int结果=0；
for（int i=0；ii）{
if（Integer.parseInt（input1[j].substring（input1[j].length（）-1））>notCrossing）{
总数+=1；
notCrossing=Integer.parseInt（input1[j].子字符串（input1[j].length（）-1））；
}
}否则{
notCrossing=Integer.parseInt（input1[j].子字符串（input1[j].length（）-1））；
}
}
如果（总计>结果）结果=总计；
}
返回结果；
}

有更优化的算法吗？

公共静态int桥计数（字符串[]input1，int input2）
public static int bridge_count(String[] input1,int input2)
{
    int[][] track=new int[input2][input2];
    int count=0;

    for(int i=0;i<input1.length;i++)
    {
        String cityCon=input1[i];
        String cityArray[]=cityCon.split("#");
        int fst=Integer.parseInt(cityArray[0]);
        int sec=Integer.parseInt(cityArray[1]);
        track[fst-1][sec-1]=-1;
    }

    int found=0;
    int maxCol=-1;

    for(int c=0;c<input2;c++)
    {
        found=-1;
        for(int j=0;j<input2;j++)
        {
            if(track[c][j]==-1)
            {
             found=j;
             break;
            }
        }    

        if(found!=-1 && maxCol<=found)
        {
            count++;
            maxCol=found;
        }    
    }
    return count;
}

{
int[]track=新int[input2][input2]；
整数计数=0；
对于（inti=0；i这在O（nLog（n））中运行

public static int maxNonOverlappingBridges(String[] bridges) {
    int overlappings1 = 0;
    int overlappings2 = 0;
    int maxIndexOfCityOnOtherSide = 0;

    /*
     * Sorting bridge connections with respect to the left index. (i.e : 2 in 2#y4)
     * O(n*log(n)) time
     */      
    Arrays.sort(bridges);

    List<Integer[]> brigesAsArray = new ArrayList<>();

    Integer[] previousBridge = null; 

    for(String b: bridges){

        if(previousBridge == null){
            String[] bridgeIndexes = b.split("#y");
            previousBridge = new Integer[]{Integer.parseInt(bridgeIndexes[0]),Integer.parseInt(bridgeIndexes[1])};
            maxIndexOfCityOnOtherSide = previousBridge[1];              
            brigesAsArray.add(previousBridge);
            continue;
        }

        String[] bridgeIndexes = b.split("#y");
        Integer[] currentBridge = new Integer[]{Integer.parseInt(bridgeIndexes[0]),Integer.parseInt(bridgeIndexes[1])};

        if(currentBridge[1] < maxIndexOfCityOnOtherSide){
            //overlapping found;
            overlappings1++;
        }else{
            maxIndexOfCityOnOtherSide = currentBridge[1];
        }

        previousBridge = currentBridge;
        brigesAsArray.add(previousBridge);
    }       

    Integer[][] bridgeIndexes = brigesAsArray.toArray(new Integer[0][0]);
    brigesAsArray.toArray(bridgeIndexes);       

    /*
     * Sorting bridge connections with respect to the right index. (i.e : 4 in 2#y4)
     * O(n*log(n)) time
     */ 

    Arrays.sort(bridgeIndexes, new Comparator<Integer[]>() {
        @Override
        public int compare(Integer[] o1, Integer[] o2) {
            return Integer.compare(o1[1], o2[1]);
        }           
    });

    previousBridge = null;

    for(Integer[] b: bridgeIndexes){

        if(previousBridge == null){
            maxIndexOfCityOnOtherSide = b[0];   
            previousBridge = b;
            continue;
        }

        if(b[0] < maxIndexOfCityOnOtherSide){
            //overlapping found;
            overlappings2++;
        }else{
            maxIndexOfCityOnOtherSide = b[0];
        }

        previousBridge = b;
        brigesAsArray.add(previousBridge);
    }   
    return (bridges.length - Math.min(overlappings1, overlappings2));
}

public static int maxNonOverlappingBridges（字符串[]桥）{
int重叠s1=0；
int-overlappings2=0；
int maxIndexOfCityOnOtherSide=0；
/*
*根据左索引对桥接连接进行排序。（即：2/2#y4）
*O（n*log（n））时间
*/      
数组。排序（桥）；
List brigesAsArray=new ArrayList（）；
整数[]previousBridge=null；
用于（字符串b：桥）{
if（上一个桥==null）{
字符串[]bridgeIndexes=b.split（#y”）；
previousBridge=newinteger[]{Integer.parseInt（bridgeIndexes[0]），Integer.parseInt（bridgeIndexes[1]）；
maxIndexOfCityOnOtherSide=previousBridge[1]；
brigesAsArray.add（先前的桥）；
继续；
}
字符串[]bridgeIndexes=b.split（#y”）；
整数[]currentBridge=新整数[]{Integer.parseInt（bridgeIndexes[0]），Integer.parseInt（bridgeIndexes[1]）；
if（另一侧的currentBridge[1]

希望这有帮助。
使用O（nLog（n））的简单解决方案

 public static int bridge_count1(String[] input1,int input2)
      {
         int count=0;
         Map<Integer,Integer> map=new TreeMap<Integer,Integer>();
         for(int i=0;i<input1.length;i++)
         {
             String cityCon=input1[i];
             String cityArray[]=cityCon.split("#");
             int fst=Integer.parseInt(cityArray[0]);
             int sec=Integer.parseInt(cityArray[1]);
             map.put(fst, sec);
         }

         Iterator<Integer> it=map.keySet().iterator();
         int max=0;
         while(it.hasNext())
         {
             int val=map.get(it.next());
             if(max<=val)
             {
                 max=val;
                 count++;
             }
        }


         return count;

  }

publicstaticintbridge\u count1（字符串[]input1，intinput2）
{
整数计数=0；
Map Map=newtreemap（）；
对于（int i=0；我不完全是一个优化，但您可以使用
Character.digit（str.charAt（…）
而不是substring和parseInt；也可以将其作为变量提取出来，这样您就不会在至少3个位置重复它。您必须有10个或更少的城市（因为您提取了一位数索引），所以循环最多运行100次。保证优化真的那么慢吗？你想优化什么？空间？时间？可读性？…实际上这是一个挑战。它失败了两个未知的测试用例。所以，挑战需要你优化什么？如果失败了两个测试用例：不要尝试优化你的代码，修复失败的测试用例。您好@kaushik。感谢您的贡献。除了代码之外，为您的答案添加一些解释会很有帮助。@greybeard:问题的主题是城市间最大不重叠桥梁的算法。您是否运行了问题所有者给出的算法？您使用的TreeM方法ap，消耗日志（n）时间。因此，此解决方案不会是O（n）。