include[HTML_REMOVED]

int flag[1000] = { 0 }, pf[1000] = { 0 };
void sort(int n, int count,int k)
{
if (count == 0)
{
for (int i = 1; i <= n; i)
{
printf(“%d “, pf[i]);
}
printf(“\n”);
return;
}
for (int i = 1; i <= n; i)
{
if (flag[i] == 1)continue;
flag[i] = 1;
pf[k] = i;
sort(n, count - 1,k+1);
flag[i] = 0;
}
}
int main()
{
int n,k=1;
scanf(“%d”, &n);
sort(n,n,k);
}

#include<iostream>

using namespace std;

int n,cnt;//全局变量初始为0
void f(int k){
    if(k==n)cnt++;//该方案可以到达对应的台阶,数量++
    else if(k>n) return ;
    //递归的边缘条件
    f(k+1);f(k+2);
    //两者跳台阶的方式:一格/两格
}

int main(){

    cin>>n;//k带代表当前在第几节台阶

    f(0);//当前是第0级台阶
    //递归就是是调用自身的过程,不一定要返回结果(深度优先搜索)
    //模拟各种路线走法的过程就行
    cout<<cnt;
}

先序遍历输入创建二叉树并遍历

include[HTML_REMOVED]

include[HTML_REMOVED]

using namespace std;

typedef struct BiNode{
char data;
struct BiNode lchild,rchild;
}BiTNode,*BiTree;

//前序遍历 根左右 创建树
void CreateBiTree(BiTree &T)
{
char ch;
cin>>ch;
if(ch==’#’) T=NULL;
else
{
T=new BiTNode();
T->data=ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
}

//中序遍历 二叉树
void InOrder(BiTree T)
{
if(T==NULL) return;
InOrder(T->lchild);
cout<[HTML_REMOVED]data<<’ ‘;
InOrder(T->rchild);
}

int main()
{
BiTree T;
CreateBiTree(T);
InOrder(T);
return 0;
}

算法1

(暴力枚举) $O(n^2)$

blablabla

时间复杂度

参考文献

C++ 代码

blablabla

算法2

(暴力枚举) $O(n^2)$

blablabla

时间复杂度

参考文献

C++ 代码

blablabla

前缀字符哈希法方法

#include<iostream>

typedef unsigned long long ULL;
const int N = 10000010,q = 131;
int n,m;
char s[N],t[N];
ULL h[N],p[N];
ULL ge(int l,int r){
    return h[r] - h[l-1]*p[r-l+1];
}
int main(){
    p[0]=1;
    std::cin>>m>>s+1>>n>>t+1;

    for(int i=1;i<=n;i++){
        h[i] = h[i-1]*q+t[i];
        p[i] = p[i-1]*q;
    }
    ULL is = 0;

    for(int i=1;i<=m;i++)is= is*q+s[i];
    for(int i=1;i+m-1<=n;i++){
        if(is==ge(i,i+m-1))std::cout<<i-1<<' ';

    }
    return 0;
}

T,R,P,S = map(int,input().split())
from collections import defaultdict,deque
g = defaultdict(list)
for _ in range(R):
    a,b,c = map(int,input().split())
    g[a].append((b,c))
    g[b].append((a,c))

ids = [-1]*(1 + T) # 每个点属于哪个连通块
blocks = [[] for _ in range(T)] # 每个连通块包含的点

import sys
sys.setrecursionlimit(10**5)
def dfs(u,idx):
    ids[u] = idx
    blocks[idx].append(u)
    for v,c in g[u]:
        if ids[v] == -1:
            dfs(v,idx)

from math import inf
from heapq import heappush,heappop
dist = [inf]*(T + 1)
st = [0]*(T + 1)
dist[S] = 0

def dj(bid):
    # 对bid连通块跑dj
    pq = []
    for x in blocks[bid]:
        heappush(pq,(dist[x],x))
    while pq:
        d,u = heappop(pq)
        if st[u]:
            continue
        st[u] = 1
        for v,c in g[u]:
            if d + c < dist[v]:
                dist[v] = d + c
                if ids[v] == ids[u]:
                    heappush(pq,(dist[v],v))
            if ids[v] != ids[u]:
                deg[ids[v]] -= 1
                if not deg[ids[v]]:
                    q.append(ids[v])

# 找连通块，连通块下标从0开始
bid = 0
for i in range(1,T + 1):
    if ids[i] == -1:
        dfs(i,bid)
        bid += 1

deg = [0]*bid
for _ in range(P):
    a,b,c = map(int,input().split())
    g[a].append((b,c))
    deg[ids[b]] += 1

# 跑拓扑序
q = deque([i for i,x in enumerate(deg) if x == 0])
while q:
    dj(q.popleft())
#print(dist)
for i in range(1,T + 1):
    print('NO PATH' if dist[i] == inf else dist[i])

全排列函数：next_permutation，前提是要排序

class Solution {
public:
    vector<vector<int>> permutation(vector<int>& nums) {
        sort(nums.begin(),nums.end());//全排列函数一定要从小到大排列
        vector<vector<int>> a;//很多组数据，所以vector套vector
        do{
            a.push_back(nums);//在a后面加上nums
        }while(next_permutation(nums.begin(),nums.end()));//全排列函数
        return a;
    }
};