📜  使用插入,删除和复制操作写入字符的最短时间

📅  最后修改于: 2021-04-27 05:09:12             🧑  作者: Mango

我们需要在屏幕上写入N个相同的字符,并且每次我们可以插入一个字符,删除最后一个字符并复制并粘贴所有已写入的字符,即在复制操作后,总写入字符将变为两倍。现在我们有时间进行插入,删除和复制。我们需要输出最少的时间来使用这些操作在屏幕上写入N个字符。

例子:

Input : N = 9    
        insert time = 1    
        removal time = 2    
        copy time = 1
Output : 5
N character can be written on screen in 5 time units as shown below,
insert a character    
characters = 1  total time = 1
again insert character      
characters = 2  total time = 2
copy characters             
characters = 4  total time = 3
copy characters             
characters = 8  total time = 4
insert character           
characters = 9  total time = 5

我们可以使用动态编程解决此问题。在手工解决了一些示例之后,我们可以观察到一种模式,在编写每个字符,我们有两种选择:通过插入获取或通过复制获取,以较少的时间为准。现在相应地写关系
假设dp [i]是在屏幕上写入i个字符的最佳时间,

If i is even then,
   dp[i] = min((dp[i-1] + insert_time), 
               (dp[i/2] + copy_time))
Else (If i is odd)
   dp[i] = min(dp[i-1] + insert_time),
              (dp[(i+1)/2] + copy_time + removal_time)

在奇数的情况下,由于要复制(i + 1)/ 2个字符会增加删除时间,因为屏幕上将需要删除一个额外的字符。

C++
// C++ program to write characters in
// minimum time by inserting, removing
// and copying operation
#include 
using namespace std;
 
//  method returns minimum time to write
// 'N' characters
int minTimeForWritingChars(int N, int insert,
                       int remove, int copy)
{
    if (N == 0)
       return 0;
    if (N == 1)
       return insert;
 
    //  declare dp array and initialize with zero
    int dp[N + 1];
    memset(dp, 0, sizeof(dp));
 
    // first char will always take insertion time
    dp[1] = insert;
 
    //  loop for 'N' number of times
    for (int i = 2; i <= N; i++)
    {
        /*  if current char count is even then
            choose minimum from result for (i-1)
            chars and time for insertion and
            result for half of chars and time
            for copy  */
        if (i % 2 == 0)
            dp[i] = min(dp[i-1] + insert,
                        dp[i/2] + copy);
 
        /*  if current char count is odd then
            choose minimum from
            result for (i-1) chars and time for
            insertion and
            result for half of chars and time for
            copy and one extra character deletion*/
        else
            dp[i] = min(dp[i-1] + insert,
                        dp[(i+1)/2] + copy + remove);
    }
    return dp[N];
}
 
// Driver code
int main()
{
    int N = 9;
    int insert = 1, remove = 2, copy = 1;
    cout << minTimeForWritingChars(N, insert,
                                remove, copy);
    return 0;
}


Java
// Java program to write characters in
// minimum time by inserting, removing
// and copying operation
 
public class GFG{
     
    // method returns minimum time to write
    // 'N' characters
    static int minTimeForWritingChars(int N, int insert,
                                      int remove, int copy)
    {
        if (N == 0)
        return 0;
        if (N == 1)
        return insert;
     
        // declare dp array and initialize with zero
        int dp[] = new int [N + 1];
         
          // first char will always take insertion time
          dp[1] = insert;
     
        // loop for 'N' number of times
        for (int i = 2; i <= N; i++)
        {
            /* if current char count is even then
                choose minimum from result for (i-1)
                chars and time for insertion and
                result for half of chars and time
                for copy */
            if (i % 2 == 0)
                dp[i] = Math.min(dp[i-1] + insert, dp[i/2] + copy);
     
            /* if current char count is odd then
                choose minimum from
                result for (i-1) chars and time for
                insertion and
                result for half of chars and time for
                copy and one extra character deletion*/
            else
                dp[i] = Math.min(dp[i-1] + insert,
                                 dp[(i+1)/2] + copy + remove);
        }
        return dp[N];
    }
     
    // Driver code to test above methods
    public static void main(String []args)
    {
        int N = 9;
        int insert = 1, remove = 2, copy = 1;
        System.out.println(minTimeForWritingChars(N, insert,remove, copy));
    }
    // This code is contributed by Ryuga
}


Python3
# Python3 program to write characters in
# minimum time by inserting, removing
# and copying operation
 
def minTimeForWritingChars(N, insrt,
                           remov, cpy):
     
    # method returns minimum time
    # to write 'N' characters
    if N == 0:
        return 0
    if N == 1:
        return insrt
 
    # declare dp array and initialize
    # with zero
    dp = [0] * (N + 1)
     
    # first char will always take insertion time
    dp[1] = insrt
     
    # loop for 'N' number of times
    for i in range(2, N + 1):
 
        # if current char count is even then
        # choose minimum from result for (i-1)
        # chars and time for insertion and
        # result for half of chars and time
        # for copy
        if i % 2 == 0:
            dp[i] = min(dp[i - 1] + insrt,
                        dp[i // 2] + cpy)
 
        # if current char count is odd then
        # choose minimum from
        # result for (i-1) chars and time for
        # insertion and
        # result for half of chars and time for
        # copy and one extra character deletion
        else:
            dp[i] = min(dp[i - 1] + insrt,
                        dp[(i + 1) // 2] +
                        cpy + remov)
 
    return dp[N]
 
# Driver Code
if __name__ == "__main__":
    N = 9
    insrt = 1
    remov = 2
    cpy = 1
    print(minTimeForWritingChars(N, insrt,
                                 remov, cpy))
 
# This code is contributed
# by vibhu4agarwal


C#
// C# program to write characters in
// minimum time by inserting, removing
// and copying operation
using System;
 
class GFG
{
    // method returns minimum time to write
    // 'N' characters
    static int minTimeForWritingChars(int N, int insert,
                                        int remove, int copy)
    {
        if (N == 0)
            return 0;
        if (N == 1)
            return insert;
     
        // declare dp array and initialize with zero
        int[] dp = new int[N + 1];
        for(int i = 0; i < N + 1; i++)
            dp[i] = 0;
     
          // first char will always take insertion time
          dp[1] = insert;
       
        // loop for 'N' number of times
        for (int i = 2; i <= N; i++)
        {
             
            /* if current char count is even then
                choose minimum from result for (i-1)
                chars and time for insertion and
                result for half of chars and time
                for copy */
            if (i % 2 == 0)
                dp[i] = Math.Min(dp[i - 1] + insert,
                            dp[i / 2] + copy);
     
            /* if current char count is odd then
                choose minimum from
                result for (i-1) chars and time for
                insertion and
                result for half of chars and time for
                copy and one extra character deletion*/
            else
                dp[i] = Math.Min(dp[i - 1] + insert,
                            dp[(i + 1) / 2] + copy + remove);
        }
        return dp[N];
    }
     
    // Driver code
    static void Main()
    {
        int N = 9;
        int insert = 1, remove = 2, copy = 1;
        Console.Write(minTimeForWritingChars(N, insert,
                                            remove, copy));
    }
}
 
//This code is contributed by DrRoot_


输出
5

时间复杂度:O(N)
辅助空间: O(N)。