Looks like the function seems to be an increasing/decreasing/increasing-then-decreasing array once you spread the input number out in array from 0 to n. You can use binary search to find the peak in the function. For each mid point, you can determine if the part of the array is decreasing, increasing or peak and then locate which part of the array likely to have the peak. You can find more details and explanation in this article

当您将数组中的输入数字从0扩展到n时，该函数看起来就像是一个increasing/decreasing/increasing-then-decreasing数组。您可以使用二进制搜索来查找函数中的峰值。对于每个中点，您可以确定阵列的部分是减少、增加还是达到峰值，然后定位阵列的哪个部分可能具有峰值。您可以在这篇文章中找到更多详细信息和解释

int maxInBitonic(int arr[], int low, int high)
{
    // find out the size of the array
    // for edge case checking
    int n = high + 1;

    // main code goes as follows
    while (low <= high) {
        // find out the mid
        int mid = low + (high - low) / 2;
        
        // if mid index value is maximum
        if(arr[mid] > arr[mid+1] and arr[mid] > arr[mid-1])
            return arr[mid];

        // reducing search space by moving to right
        else if (arr[mid] < arr[mid + 1])
            low = mid + 1;

        // reducing search space by moving to left
        else
            high = mid - 1;
    }

    return arr[high];
}

Unfortunately I am unfamiliar with C++ to assist you in code, but these points might help.

不幸的是，我不熟悉C++来帮助您编写代码，但这些要点可能会有所帮助。

1. What about checking for the gradient of the function and moving in the same direction. Since your function (as you describe it) only have one maximal point, I think this is the correct approach.

   
   



2. Gradient calculation: grad(x1 - x2) = (f(x1) - f(x2))/ (x1 - x2)

   
   



3. Apply Binary search to restrict the search domain. So if you check the gradient between 0 and 1 and it's positive for example. Then we move to the right side along the gradient since we know the function is increasing moving to the side of 1. Then we move our search to between 1 and 2^64 - 1, cutting the search domain in half. Rinse and repeat.

   
   



4. So if we keep doing this, at some point we either hit gradient of 0 or very small gradient value (~0), and even your gradient value can be oscillating between negative and positive, meaning you are close to a local max/min (but in our function's case, it is a max). Here you can manually tweak your search to more quickly converge to that final result if needed. Or just decide to stop on a estimated value.

   
   



5. But since you're doing binary search, i think it will converge quickly anyways. Step 4 is usually needed in gradient decend where we have no idea about the domain size. This case however, there is a domain size and binary search is good fit.

   
   

Hope this help, good luck with your work!

希望这对你有所帮助，祝你工作顺利！