Question

某种字符串处理语言提供了一种原始操作，它将字符串分成两部分。由于此操作涉及复制原始字符串，因此无论剪切的位置如何，对于长度为n的字符串，都需要n个时间单位。现在假设您要将字符串分成许多部分。中断的顺序可能会影响总运行时间。例如，如果你想在3号和10号位置剪切一个20个字符的字符串，那么在第3个位置进行第一次剪切会产生20 + 17 = 37的总成本，而在第10个位置进行第一次剪切会产生更好的成本20+ 10 = 30。

给出一个动态编程算法，给定长度为n的字符串中m个切口的位置，找到将字符串分解为m + 1个片段的最小成本。

这个问题来自“算法”第6章6.9。

由于这个问题没有答案，这就是我的想法。

将OPT(i,j,n)定义为打破字符串的最低成本，开始索引为i，字符串结束索引为j，剩余剪切数为n可以使用。

这是我得到的：

OPT(i,j,n) = min {OPT(i,k,w) + OPT(k+1,j,n-w) + j-i} for i<=k<j and 0<=w<=n

是对还是不对？请帮忙，谢谢！

Answer 1

我认为你的复发关系可以变得更好。这就是我想出的，定义成本（i，j）是从索引i到j切割字符串的成本。然后，

cost(i,j) = min {length of substring + cost(i,k) + cost(k,j) where i < k < j}

Answer 2

 void  s_cut()    
  {
    int l,p;
    int temp=0;
    //ArrayList<Integer> al = new ArrayList<Integer>();
    int al[];
    Scanner s=new Scanner(System.in);
    int table[][];
    ArrayList<Integer> values[][];
    int low=0,high=0;
    int min=0;

    l=s.nextInt();
    p=s.nextInt();

    System.out.println("The values are "+l+"  "+p);

    table= new int[l+1][l+1];
    values= new ArrayList[l+1][l+1];
    al= new int[p];

    for(int i=0;i<p;i++)
    {
        al[i]=s.nextInt();

    }

    for(int i=0;i<=l;i++)
    for(int j=0;j<=l;j++)
        values[i][j]=new ArrayList<Integer>();

    System.out.println();

    for(int i=1;i<=l;i++)
        table[i][i]=0;
    //Arrays.s
    Arrays.sort(al);

    for(int i=0;i<p;i++)
    {
        System.out.print(al[i]+ "  ");

    }


    for(int len=2;len<=l;len++)
    {
        //System.out.println("The length is  "+len);

        for(int i=1,j=i+len-1;j<=l;i++,j++)
        {

            high= min_index(al,j-1);
            low= max_index(al,i);

            System.out.println("Indices are "+low+"  "+high);

            if(low<=high && low!=-1 && high!=-1)
            {

            int cost=Integer.MAX_VALUE;;

            for(int k=low;k<=high;k++)
            {
                //if(al[k]!=j)
                temp=cost;
                cost=Math.min(cost, table[i][al[k]]+table[al[k]+1][j]);

                if(temp!=cost)
                {
                    min=k; 
                    //values[i][j].add(al[k]);
                    //values[i][j].addAll(values[i][al[k]]);
                    //values[i][j].addAll(values[al[k]+1][j]);
                    //values[i][j].addAll(values[i][al[k]]);
                }

                //else
                //cost=0;
            }

            table[i][j]= len+cost;

            values[i][j].add(al[min]);
            //values[i][j].addAll(values[i][al[min]]);
            values[i][j].addAll(values[al[min]+1][j]);
            values[i][j].addAll(values[i][al[min]]);

            }

            else
                table[i][j]=0;

            System.out.println(" values are "+i+"  "+j+"  "+table[i][j]);
        }
    }

    System.out.println(" The minimum cost is "+table[1][l]);

    //temp=values[1][l];
    for(int e: values[1][l])
    {
        System.out.print(e+"-->");

    }

}

上述解决方案具有O（n ^ 3）的复杂性。

动态编程，以最小的成本打破字符串

2 个答案: