可能是我没明白，不过我觉得这个可以直接暴搜。
第一次假设一直往右走，然后用一个序列将其中的坐标全部存起来，到终点之后你想输出路径；
第二次假设前n-1步往右走，最后一步往左走，终点后坐标逆向输出；
第三次假设前n-2步往右走，第n-1步往左走，第n-2步往右走；
第四次假设前n-2步往右走，最后两步往左走；
……
以此类推，一直到最后一轮都是往左走就可以了。
就是每一步都有两个方向，全部跑一遍就好了。方案一共有2^n种。
代码如下：

#include<stdio.h>
#define N 20
int path[N];
void dfs(int k,int n)
{
    if(k<=n)//走到第k步
    {
        path[k] = path[k-1]+k;
        dfs(k+1,n);
        path[k] = path[k-1]-k;
        dfs(k+1,n);
    }
    else//走完n步
    {
        for(int i=0; i<n; i++)
        {
            printf("(%d,%d)",path[i],path[i+1]);
        }
        printf("\n");
        return ;
    }
    return ;
}
int main()
{
    int n;
    scanf("%d",&n);
    path[0]=0;
    dfs(1,n);
    return 0;
}

上面有人说了, 查找状态 表示出来 是一个满二叉树. 那么数据结构就很明显了, 一个vector. 可以参考堆 的实现, 第一级 index为0, 第二级为1, 2... 查找显然是一个bsf, 找到后 向上很容易 逆推出路径(堆中的parent函数). over

Challenge accepted.

#include <stdio.h>
#include <stdlib.h>

static int ensureCapacity(int **arr, int *capacity, int size)
{
    if (size <= *capacity)
        return 0;
    *arr = (int*)realloc(*arr, (*capacity << 1) * sizeof(int));
    if (*arr)
        *capacity <<= 1;
    ensureCapacity(arr, capacity, size);
    return *arr == NULL;
}

static int lChild(int n)
{
    return (n << 1) + 1;
}

static int rChild(int n)
{
    return (n << 1) + 2;
}

static int parent(int n)
{
    return n == 0 ? n : (n - 1) >> 1;
}

static void printPath(int *arr, int i)
{
    int p;
    if (i == 0)
        return;
    p = parent(i);
    printPath(arr, p);
    printf("(%d, %d)\n", arr[p], arr[i]);  
}

int searchPath(int N)
{
    int *arr;
    int capacity, i, step, left, right, rc;

    capacity = 64;
    rc = 0;
    if ((arr = (int*)malloc(capacity * sizeof(int))) == NULL)
        goto err;
    left = right = step = 0;
    arr[0] = 0;
    while (1) {
        step++;
        if (ensureCapacity(&arr, &capacity, rChild(right) + 1))
            goto err;
        for (i = left; i <= right; i++) {
            if (arr[i] == N) {
                printPath(arr, i);
                goto done;
            }
            arr[lChild(i)] = arr[i] - step;
            arr[rChild(i)] = arr[i] + step;
        }
        left = lChild(left);
        right = rChild(right);
    }

err:
    rc = -1;
done:
    if (arr)
        free(arr);
    return -1;
}

int main(void) {
    searchPath(100);
    return 0;
}

结果:

(0, -1)
(-1, -3)
(-3, -6)
(-6, -10)
(-10, -5)
(-5, 1)
(1, 8)
(8, 16)
(16, 25)
(25, 35)
(35, 46)
(46, 58)
(58, 71)
(71, 85)
(85, 100)

//斐波那契数列

int a = 0;//开始
int b = 0;
int c = 0;

a = a + 1;//第一步
b = c;//第一步的起点
c = b + a;//第一步的终点
//输出（b,c）

a = a + 1;//第二步
b = c;//第二步的起点
c = b + a;//第二步的终点
//输出（b,c）

//第N步，重复执行上面的，这有什么困难的吗？
while(a <= N){
  a = a + 1;//第a步
  b = c;//第a步的起点
  c = b + a;//第a步的终点
  //输出（b,c）
}

我不会C++，你凑合看吧，大概就这意思。