用C语言，输入两个整数n，m（0<n,m<100000）每一次，第一个整数可以执行乘2，减1，加1三种操作的任意一种，求n到m至少需要多少次这样的操作。

这个问题可以使用广度优先搜索（BFS）来解决。我们可以将每个状态看作一个节点，每个操作看作一条边，然后从起点n开始进行BFS，直到找到目标节点m为止。在搜索过程中，我们需要记录每个节点的深度，即从起点n到该节点的最短路径长度，最终的答案就是目标节点m的深度。

以下是C语言的代码实现：

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

#define MAXN 100000

int n, m;
int vis[MAXN+1]; // 标记数组，记录每个节点是否已经访问过
int depth[MAXN+1]; // 深度数组，记录每个节点的深度

typedef struct {
    int x, d; // x表示节点编号，d表示深度
} Node;

Node q[MAXN+1]; // 队列，用于BFS

int bfs(int n, int m) {
    int head = 0, tail = 0;
    q[tail++] = (Node){n, 0};
    vis[n] = 1;
    while (head < tail) {
        Node u = q[head++];
        if (u.x == m) return u.d; // 找到目标节点，返回深度
        if (u.x * 2 <= MAXN && !vis[u.x*2]) {
            q[tail++] = (Node){u.x*2, u.d+1};
            vis[u.x*2] = 1;
            depth[u.x*2] = u.d+1;
        }
        if (u.x - 1 >= 0 && !vis[u.x-1]) {
            q[tail++] = (Node){u.x-1, u.d+1};
            vis[u.x-1] = 1;
            depth[u.x-1] = u.d+1;
        }
        if (u.x + 1 <= MAXN && !vis[u.x+1]) {
            q[tail++] = (Node){u.x+1, u.d+1};
            vis[u.x+1] = 1;
            depth[u.x+1] = u.d+1;
        }
    }
    return -1; // 没有找到目标节点，返回-1
}

int main() {
    scanf("%d%d", &n, &m);
    printf("%d\n", bfs(n, m));
    return 0;
}

对于输入样例n=3, m=11，程序输出为4，表示从3到11至少需要4次操作。