通过避免给定索引B |指针，可以N步达到指针的最大索引。套装2

给定两个整数N和B ，任务是在N个步骤中从第0^个索引开始打印数组中可以达到的最大索引，而不会在任何时候将其自身放置在索引B上，在^第i^个步骤中，指针可以将i索引向右移动。

例子：

Input: N = 4, B = 6
Output: 9
Explanation: Following sequence of moves maximizes the index that can be reached.

• Step 1: Initially, pos = 0. Remain in the same position.
• Step 2: Move 2 indices to the right. Therefore, current position = 0 + 2 = 2.
• Step 3: Move 3 indices to the right. Therefore, current position = 2 + 3 = 5.
• Step 4: Move 4 indices to the right. Therefore, current position = 5 + 4 = 9.

Input: N = 2, B = 2
Output: 3

天真的方法：有关解决问题的最简单方法，请参阅上一篇文章。

时间复杂度： O(N ³ )
辅助空间： O(1)

高效的方法：解决问题的最佳方法是基于以下观察：

Observation:

• If observed carefully, the answer is either the sequence from the arithmetic sum of steps or that of the arithmetic sum of steps – 1.
• This is because, the highest possible number without considering B, is reachable by not waiting (which would give the arithmetic sum).
• But if B is a part of that sequence, then waiting at 0 in the first steps ensures that the sequence does not intersect with the sequence obtained without waiting (as it is always 1 behind).
• Any other sequence (i.e waiting at any other point once or more number of times) will always yield a smaller maximum reachable index.

请按照以下步骤解决问题：

• 初始化两个指针i = 0和j = 1。
• 初始化一个变量，例如sum，以存储前N个自然数的和，即N *(N +1)/ 2。
• 初始化一个变量，例如cnt = 0，并初始化另一个变量，例如flag = false。
• 迭代直到cnt小于N。
  • 用j递增i 。
  • 递增j 。
  • 增量cnt 。
  • 如果在任何迭代中， i等于B ，则将flag设置为true并退出循环。
• 如果flag为false ，则打印sum 。否则，打印总和– 1。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the maximum
// index the pointer can reach
int maximumIndex(int N, int B)
{
    // Initialize two pointers
    int i = 0, j = 1;
 
    // Stores number of steps
    int cnt = 0;
 
    // Stores sum of first N
    // natural numbers
    int sum = N * (N + 1) / 2;
 
    bool flag = false;
 
    while (cnt < N) {
 
        // Increment i with j
        i += j;
 
        // Increment j with 1
        j++;
 
        // Increment count
        cnt++;
 
        // If i points to B
        if (i == B) {
 
            // Break
            flag = true;
            break;
        }
    }
 
    // Print the pointer index
    if (!flag) {
        cout << sum;
    }
    else
        cout << sum - 1;
}
 
// Driver Code
int main()
{
    // Given value of N & B
    int N = 4, B = 6;
 
    // Function call to find maximum
    // index the pointer can reach
    maximumIndex(N, B);
 
    return 0;
}

Java

// Java program for the above approach
class GFG{
     
// Function to find the maximum
// index the pointer can reach
static void maximumIndex(int N, int B)
{
     
    // Initialize two pointers
    int i = 0, j = 1;
 
    // Stores number of steps
    int cnt = 0;
 
    // Stores sum of first N
    // natural numbers
    int sum = N * (N + 1) / 2;
 
    boolean flag = false;
 
    while (cnt < N)
    {
         
        // Increment i with j
        i += j;
 
        // Increment j with 1
        j++;
 
        // Increment count
        cnt++;
 
        // If i points to B
        if (i == B)
        {
             
            // Break
            flag = true;
            break;
        }
    }
 
    // Print the pointer index
    if (!flag == true)
    {
        System.out.print(sum);
    }
    else
    {
        System.out.print(sum - 1);
    }
}
 
// Driver Code
public static void main (String[] args)
{
     
    // Given value of N & B
    int N = 4, B = 6;
 
    // Function call to find maximum
    // index the pointer can reach
    maximumIndex(N, B);
}
}
 
// This code is contributed by AnkThon

Python3

# Python3 program for the above approach
 
# Function to find the maximum
# index the pointer can reach
def maximumIndex(N, B):
     
    # Initialize two pointers
    i, j = 0, 1
 
    # Stores number of steps
    cnt = 0
 
    # Stores sum of first N
    # natural numbers
    sum = N * (N + 1) // 2
 
    flag = False
 
    while (cnt < N):
 
        # Increment i with j
        i += j
 
        # Increment j with 1
        j += 1
 
        # Increment count
        cnt += 1
 
        # If i points to B
        if (i == B):
 
            # Break
            flag = True
            break
 
    # Print the pointer index
    if (not flag):
        print (sum)
    else:
        print(sum - 1)
 
# Driver Code
if __name__ == '__main__':
     
    # Given value of N & B
    N, B = 4, 6
 
    # Function call to find maximum
    # index the pointer can reach
    maximumIndex(N, B)
 
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
 
class GFG{
     
// Function to find the maximum
// index the pointer can reach
static void maximumIndex(int N, int B)
{
     
    // Initialize two pointers
    int i = 0, j = 1;
 
    // Stores number of steps
    int cnt = 0;
 
    // Stores sum of first N
    // natural numbers
    int sum = N * (N + 1) / 2;
 
    bool flag = false;
 
    while (cnt < N)
    {
         
        // Increment i with j
        i += j;
 
        // Increment j with 1
        j++;
 
        // Increment count
        cnt++;
 
        // If i points to B
        if (i == B)
        {
             
            // Break
            flag = true;
            break;
        }
    }
 
    // Print the pointer index
    if (!flag == true)
    {
        Console.Write(sum);
    }
    else
    {
       Console.Write(sum - 1);
    }
}
 
// Driver Code
static public void Main ()
{
     
    // Given value of N & B
    int N = 4, B = 6;
 
    // Function call to find maximum
    // index the pointer can reach
    maximumIndex(N, B);
}
}
 
// This code is contributed by avijitmondal1998

Javascript

// JavaScript program for the above approach
 
// Function to find the maximum
// index the pointer can reach
function maximumIndex(N, B)
{
    // Initialize two pointers
    let i = 0, j = 1;
 
    // Stores number of steps
    let cnt = 0;
 
    // Stores sum of first N
    // natural numbers
    let sum = Math.floor(N * (N + 1) / 2);
 
    let flag = false;
 
    while (cnt < N) {
 
        // Increment i with j
        i += j;
 
        // Increment j with 1
        j++;
 
        // Increment count
        cnt++;
 
        // If i points to B
        if (i == B) {
 
            // Break
            flag = true;
            break;
        }
    }
 
    // Print the pointer index
    if (!flag) {
        document.write(sum);
    }
    else
        document.write(sum - 1);
}
 
// Driver Code
 
    // Given value of N & B
    let N = 4, B = 6;
 
    // Function call to find maximum
    // index the pointer can reach
    maximumIndex(N, B);
 
// This code is contributed by Surbhi Tyagi.

输出：

9

时间复杂度： O(N)
辅助空间： O(1)