搜索专题（持续更新）

最新推荐文章于 2022-01-14 15:05:04 发布
最新推荐文章于 2022-01-14 15:05:04 发布
阅读量196 收藏 2
点赞数 1
分类专栏： 机试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41995258/article/details/88924065
版权

一、BFS

eg1. 《算法笔记》P276
《算法笔记》P276

思路分析:

本题是连通块个数问题，利用搜索的方法来解决，DFS和BFS都可以。
方法一： DFS——适用于数据较小
写法1： 本题是要求在“0”里边搜索“1”，因而可以在DFS的过程当中，将已搜索到的“1”变为“0”，这样就避免了对同一个“1”的重复搜索。
写法2： 利用标记数组vis，标记出已经访问过的位置，避免重复访问。

方法二： BFS——适用于数据较大

代码——方法一
写法1
#include <cstdio>
#include <queue>
using namespace std;

const int maxn = 100;

int n, m;
int matrix[maxn][maxn];  
bool inq[maxn][maxn] = {false};
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};

void DFS(int x, int y)
{
    matrix[x][y] = 0; 
    for(int i=0; i<4; i++)
    {
        int xx = x + X[i];
        int yy = y + Y[i];
        if(xx>=n || xx<0 || yy>=m || yy<0 || matrix[xx][yy]==0)
        {
            continue; 
        }
        if(matrix[xx][yy] == 1)
        {
            DFS(xx, yy);
        }
    }
}

int main()
{
    freopen("input.txt", "r", stdin);
    scanf("%d %d", &n, &m);
    for(int x=0; x<n; x++)
    {
        for(int y=0; y<m; y++)
        {
            scanf("%d", &matrix[x][y]);
        }
    }
    int ans = 0;
    for(int x=0; x<n; x++)
    {
        for(int y=0; y<m; y++)
        {
            if(matrix[x][y]==1 && inq[x][y]==false)
            {
                ans++;
                DFS(x, y);
            }
        }
    }
    printf("%d\n", ans);
    fclose(stdin);

    return 0;
}
写法2
#include <cstdio>
#include <queue>
using namespace std;

const int maxn = 100;

int n, m;
int matrix[maxn][maxn];  
bool inq[maxn][maxn] = {false};
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};

void DFS(int x, int y)
{
    if(x>=n || x<0 || y>=m || y<0)
    {
        return ;
    }
    if(matrix[x][y]==0 || inq[x][y]==true)
    {
        return ;
    }
    inq[x][y] = true;
    for(int i=0; i<4; i++)
    {
        int newX = x + X[i];
        int newY = y + Y[i];
        DFS(newX, newY);
    } 
}

int main()
{
    freopen("input.txt", "r", stdin);
    scanf("%d %d", &n, &m);
    for(int x=0; x<n; x++)
    {
        for(int y=0; y<m; y++)
        {
            scanf("%d", &matrix[x][y]);
        }
    }
    int ans = 0;
    for(int x=0; x<n; x++)
    {
        for(int y=0; y<m; y++)
        {
            if(matrix[x][y]==1 && inq[x][y]==false)
            {
                ans++;
                DFS(x, y);
            }
        }
    }
    printf("%d\n", ans);
    fclose(stdin);

    return 0;
}
代码——方法二
#include <cstdio>
#include <queue>
using namespace std;

const int maxn = 100;

struct node
{
    int x, y;
}Node;

int n, m;
int matrix[maxn][maxn];  
bool inq[maxn][maxn] = {false};
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};

bool judge(int x, int y)
{
    if(x>=n || x<0 || y>=m || y<0)
    {
        return false;
    }
    if(matrix[x][y]==0 || inq[x][y]==true)
    {
        return false;
    }
    return true;
}

void BFS(int x, int y)
{
    queue<node> Q;
    Node.x = x;
    Node.y = y;
    Q.push(Node);
    inq[Node.x][Node.y] = true;
    while(!Q.empty())
    {
        node top = Q.front();
        Q.pop();
        for(int i=0; i<4; i++)
        {
            int newX = top.x + X[i];
            int newY = top.y + Y[i];
            if(judge(newX, newY))
            {
                Node.x = newX;
                Node.y = newY;
                Q.push(Node);
                inq[Node.x][Node.y] = true;
            }
        }
    }
}

int main()
{
    freopen("input.txt", "r", stdin);
    scanf("%d %d", &n, &m);
    for(int x=0; x<n; x++)
    {
        for(int y=0; y<m; y++)
        {
            scanf("%d", &matrix[x][y]);
        }
    }
    int ans = 0;
    for(int x=0; x<n; x++)
    {
        for(int y=0; y<m; y++)
        {
            if(matrix[x][y]==1 && inq[x][y]==false)
            {
                ans++;
                BFS(x, y);
            }
        }
    }
    printf("%d\n", ans);
    fclose(stdin);

    return 0;
}

eg2. 《算法笔记》P278
在这里插入图片描述
在这里插入图片描述

思路分析：

将每个结点带上层次属性，进行BFS，输出end结点的层次即可。

注：如果需要输出最终层次，要使用BFS。 因为BFS采用队列可以存储下来每次遍历到的结点全部信息。而DFS采用迭代，我才疏学浅不知道怎么输出。。。。最后在输出end结点层次时，一定要记得把从队列中取出的结点信息赋给end，因为队列中的结点信息是副本，与真实的结点不一定一致。

代码
#include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;

const int maxn = 110;
char maze[maxn][maxn];
bool inq[maxn][maxn] = {false};
int n, m; // n*m迷宫 

int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};

struct node 
{
	int x, y;
	int layer;
}start_, end_, Node;

bool judge(int x, int y)
{
	if(x<0 || x>=n || y<0 || y>=m)
	{
		return false;
	}
	if(maze[x][y]=='*' || inq[x][y]==true)
	{
		return false;
	}
	return true;
}

void BFS()
{
	queue<node> q;
	q.push(start_);
	inq[strat_.x][start_.y] = true;
	while(!q.empty())
	{
		node top = q.front();
		q.pop();
		if(top.x==end_.x && top.y==end_.y) // 到达终止点 
		{
			end_.layer = top.layer; // 一定要记得把值赋给end！！！！！！ 
			break; 
		}
		for(int i=0; i<4; i++)
		{
			int new_x = top.x + dx[i];
			int new_y = top.y + dy[i];
			if(judge(new_x, new_y) == true)
			{
				Node.x = new_x;
				Node.y = new_y;
				Node.layer = top.layer + 1;
				q.push(Node);
				inq[Node.x][Node.y] = true;
			}
		}
	}
}

int main()
{
	//freopen("input.txt", "r", stdin);
	scanf("%d %d", &n, &m);
    for(int x=0; x<n; x++)
    {
        getchar(); 
        for(int y=0; y<m; y++)
        {
            scanf("%c", &maze[x][y]);
        }
    }
    scanf("%d %d %d %d", &start_.x, &start_.y, &end_.x, &end_.y);
	start_.layer = 0; // 出发点层次深度为0	
	BFS();
	printf("%d\n", end_.layer);
	
	//fclose(stdin);
	return 0;
}

eg3. PAT A1091 Acute Stroke
在这里插入图片描述
在这里插入图片描述

题目大意：

给出一个三维数组，元素值为0、1。要求计算所有“1连通块”中元素的个数之和（连通块中1的个数要大于T，否则忽略）。

思路分析：

本题是三维的连通块计数，同二维方法一样，只不过多增加了两个搜索维度，用BFS即可解决。

注1：循环遍历时，一定要注意z轴是最外层循环！

注2：更新入队标记vis时，要在入队时更新，而不是在出队时，否则会带来影响！！！！！

代码（AC）
#include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;

struct node 
{
	int x, y, z;
}Node;

int m, n, l, t;
int pixel[1290][130][65]; // 三维矩阵
bool inq[1290][130][65] = {false}; // 入队标记 

int dx[6] = {1, -1, 0, 0, 0, 0};
int dy[6] = {0, 0, 1, -1, 0, 0};
int dz[6] = {0, 0, 0, 0, 1, -1};

bool judge(int x, int y, int z)
{
	if(x<0 || x>=m || y<0 || y>=n || z<0 || z>=l)
		return false;
	if(pixel[x][y][z]==0 || inq[x][y][z]==true)
		return false;
	return true;
}

int BFS(int x, int y, int z)
{
	queue<node> q;
	Node.x = x;
	Node.y = y;
	Node.z = z;
	q.push(Node);
	int num = 0; // 该连通块中 1 的个数 
	inq[Node.x][Node.y][Node.z] = true; // 更新状态 
	while(!q.empty())
	{
		node top = q.front();
		q.pop();
		num++; // 每从队列中取出一个，就 +1 
		//inq[top.x][top.y][top.z] = true; 
		// 因为inq表示已经在队列中，所以要在入队时更新状态，而不是在出队时，否则会有影响！！！ 
		for(int i=0; i<6; i++)
		{
			int new_x = top.x + dx[i];
			int new_y = top.y + dy[i];
			int new_z = top.z + dz[i];
			if(judge(new_x, new_y, new_z))
			{
				Node.x = new_x;
				Node.y = new_y;
				Node.z = new_z;	
				q.push(Node);
				inq[Node.x][Node.y][Node.z] = true; // 更新状态
			}		
		}
	}
	if(num >= t)
		return num;
	else 
		return 0; 
}

int main()
{
	freopen("input.txt", "r", stdin);
	scanf("%d %d %d %d", &m, &n, &l, &t);
	for(int k=0; k<l; k++)
		for(int i=0; i<m; i++)
			for(int j=0; j<n; j++)
				scanf("%d", &pixel[i][j][k]);
	int ans = 0;
	for(int k=0; k<l; k++)
	{
		for(int i=0; i<m; i++)
		{
			for(int j=0; j<n; j++)
			{
				if(pixel[i][j][k]==1 && inq[i][j][k]==false)
				{
					ans += BFS(i, j, k);
				}
			}
		}
	}
	printf("%d\n", ans);
	
	fclose(stdin);
	return 0;	
}

二、递归

递归的重点在于，找到递归边界和递归式。

eg1. 求解n的阶乘

int F(int n)
{
	if(n==0) // 递归边界
		return 1;
	else 
		return F(n-1) * n; // 递归式
}

eg2. 斐波那契数列

int F(int n) // F(0)=1, F(1)=1, F(n)=F(n-1)+F(n-2)
{
	if(n==0 || n==1)
		return 1;
	else 
		return F(n-1) + F(n-2);
}

eg3. 全排列问题
在这里插入图片描述

思路分析：

全排列问题是典型的递归问题，只需要每次都让任意一个数，分别作为递归子序列的第一个元素，直至元素个数达到n，达到递归边界。

代码
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 11;
int P[maxn]; // 输出序列
bool hashtable[maxn] = {false}; // 记录是否已被存储 
int n;

void generateP(int index) // 处理第index位的输出
{
	if(index > n)
	{
		for(int i=1; i<=n; i++)
		{
			printf("%d ", P[i]);
		}
		printf("\n");
		return ;
	}
	for(int x=1; x<=n; x++)
	{
		if(hashtable[x] == false)
		{
			P[index] = x;
			hashtable[x] = true;
			generateP(index+1);
			hashtable[x] = false;
		}
	}
} 

int main()
{
	scanf("%d", &n);
	generateP(1);
	
	return 0;
}

eg4. n皇后问题
在这里插入图片描述

思路分析：

n皇后问题是改进的全排列问题。唯一加的一个约束条件就是，任意两位置不能在同一对角线上 （行、列坐标之差不等）。

解法一： 得到全部全排列，筛选出任意两点不在同一对角线上的情况。

解法二： 在得到全排列的过程当中，便进行约束限制，如果出现在同一对角线上的情况，跳过不记录此情况。最终得到的全排列结果就是满足题意的结果。

代码——解法一
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

const int maxn = 11;
int P[maxn];
bool hashtable[maxn] = {false};
int n;

int cnt = 0;
void generateP(int index) // 处理第index位的元素 
{
	if(index > n) // 递归边界 
	{
		bool flag = true;
		for(int i=1; i<=n; i++)
		{
			for(int j=i+1; j<=n; j++)
			{
				if(abs(i-j) == abs(P[i]-P[j])) // 任意两位置不在同一对角线上 
				{
					flag = false;
					break;
				}
			}
		}
		cnt += flag;
		return ;
	}
	for(int x=1; x<=n; x++)
	{
		if(hashtable[x] == false)
		{
			P[index] = x;
			hashtable[x] = true;
			generateP(index+1);
			hashtable[x] = false;
		}
	}
}

int main()
{
	scanf("%d", &n);
	generateP(1);
	printf("%d", cnt);
	
	return 0;
}
代码——解法二
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

const int maxn = 11;
int P[maxn];
bool hashtable[maxn] = {false};
int n, cnt = 0;

void generateP(int index)
{
	if(index > n)
	{
		cnt++; // 能到达的都是满足题意的解 
		return ;	
	}
	for(int x=1; x<=n; x++)
	{
		if(hashtable[x] == false)
		{
			P[index] = x;
			bool flag = true;
			for(int pre=1; pre<index; pre++) // 当前位置的值与之前已插入的值进行比较 
			{
				if(abs(pre-index) == abs(P[pre]-P[index]))	
				{
					flag = false;
					break;
				}
			} 
			if(flag == true)
			{
				P[index] = x;
				hashtable[x] = true;
				generateP(index+1);
				hashtable[x] = false;
			}
		}
	}
}

int main()
{
	scanf("%d", &n);
	generateP(1);
	printf("%d", cnt);
	
	return 0; 
}

eg5. 素数环问题
在这里插入图片描述
在这里插入图片描述

题目大意：

给定1~n，将数字填入环中，使得任意相邻两数之和为素数。（第一个数字固定为1）

思路分析：

素数环问题也是一道典型的改进全排列问题，只是增加了一个相邻数字之和为素数的条件。

具体思路和n皇后问题一致，只是把约束条件更换了。且由于第一位已固定为1，所以main函数中调用此函数时，从第二位开始递归，因而传参为2。

代码
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

const int maxn = 20;
int P[maxn];
bool hashtable[maxn] = {false};
int n;

void init()
{
	fill(hashtable, hashtable+maxn, false);
	fill(P, P+maxn, 0);
	hashtable[1] = true;
	P[1] = 1; // 第一个位置始终是1	
}

bool isPrime(int a, int b)
{
	int x = a + b;
	if(x <= 1)
		return false;
	int sqr = (int)sqrt(1.0*x);
	for(int i=2; i<=sqr; i++)
	{
		if(x%i == 0) // 不是素数 
		{
			return false;
		}
	}
	return true;
}

void generateP(int index)
{
	if(index > n)
	{
		if(isPrime(P[n], 1) == true) // 最后一个元素与1之和为素数 
		{
			for(int i=1; i<=n; i++)
			{
				printf("%d ", P[i]);
			}
			printf("\n");
		}
		
		return ;	
	}	
	for(int x=2; x<=n; x++)
	{
		if(hashtable[x] == false)
		{
			P[index] = x;
			if(isPrime(P[index], P[index-1]) == true) // 之和是素数 
			{
				P[index] = x;
				hashtable[x] = true;
				generateP(index+1);
				hashtable[x] = false;
			}
		}
	}
} 

int main()
{
	freopen("input.txt", "r", stdin);
	int cnt = 1;
	while(scanf("%d", &n) != EOF)
	{
		init();
		printf("Case %d:\n", cnt++);
		generateP(2); // 从第2位开始 
	}
		
	fclose(stdin);
	return 0;
}

eg6. 汉诺塔问题（一）
在这里插入图片描述

void tower(int n, char x, char y, char z) // n为圆盘数，x初始塔，y辅助塔，z目标塔 -> 把n个圆盘从x移至z
{
	tower(n-1, x, z, y); // 把n-1个圆盘从x移至y
	cout << "From " << x << "To " << z << endl;
	tower(n-1, y, x, z); // 把n-1个圆盘从y移至z	
}

eg7. 汉诺塔问题（三）
在这里插入图片描述

思路分析：

要将n个圆盘从A移到C：F(n)
①需要先将上面n-1个圆盘从A移到C：F(n-1)
②再将最后一个圆盘从A移到B：1
③再将n-1个圆盘从C移到A：F(n-1)
④再将最后一个圆盘从B移到C：1
⑤最后将n-1个圆盘从A移到C：F(n-1)

综上，F(n)=3*F(n-1)+2 && F(1)=2

代码：
long long F(int n)
{
	if(n == 1)
		return 2;
	else 
		return 3*F(n-1)+2;
}

三、DFS

eg1. 背包问题
在这里插入图片描述

思路分析：

递归方式：每件物品都有选或者不选两种选择；
递归终点：访问完所有物品n or 总体积>V。

每次都要对物品进行选择，因此DFS函数的参数必须记录当前处理的物品编号index。
题目中涉及到物品的总重量和价值，因此也需要参数sumW、sumC来记录在处理当前物品之前已选物品的总重量和总价值。

如果不选index号物品，那么sumW、sumC就将不变，接下来处理index+1号物品；
如果选index号物品，那么sumW+w[index]，sumC+c[index]，接下来处理index+1号物品。

代码——未剪枝
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 30;
int w[maxn], c[maxn];
int n, V;
int maxValue = 0;

void DFS(int index, int sumW, int sumC)
{
	if(index >= n) // 处理完所有物品（递归边界） 
	{
		if(sumW <= V) // 选择在容量范围内的 
		{
			maxValue = max(maxValue, sumC);	
		}
		return ;
	}
	DFS(index+1, sumW, sumC); // 不选第index件物品
	DFS(index+1, sumW+w[index], sumC+c[index]); // 选第index件物品 
}

int main()
{
	freopen("input.txt", "r", stdin);
	scanf("%d %d", &n, &V);
	for(int i=0; i<n; i++)
	{
		scanf("%d", &w[i]); // 每件物品重量 
	}
	for(int i=0; i<n; i++)
	{
		scanf("%d", &c[i]); // 每件物品价值 
	}
	DFS(0, 0, 0); // 从第0件物品开始，初始价值、重量都为0 
	printf("%d", maxValue);
	
	fclose(stdin);
	return 0;	
}
代码——剪枝
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 30;
int w[maxn], c[maxn];
int n, V;
int maxValue = 0;

void DFS(int index, int sumW, int sumC)
{
	if(index >= n)
	{
		maxValue = max(maxValue, sumC); // 在所有满足题意的结果中找最大的 
		return ;	
	}
	DFS(index+1, sumW, sumC); // 不选第index件商品 
	if(sumW+w[index] <= V) // 加入该物品后，不会超过容量限制 
	{
		DFS(index+1, sumW+w[index], sumC+c[index]); // 选第index件商品 
	}
}

int main()
{
	freopen("input.txt", "r", stdin);
	scanf("%d %d", &n, &V);
	for(int i=0; i<n; i++)
	{
		scanf("%d", &w[i]); // 每件物品重量 
	}
	for(int i=0; i<n; i++)
	{
		scanf("%d", &c[i]); // 每件物品价值 
	}
	DFS(0, 0, 0); // 从第0件物品开始，初始价值、重量都为0 
	printf("%d", maxValue);
	
	fclose(stdin);
	return 0;	
}

eg2. 给定n个整数，从中选择k个数，使之和为x。若存在多种情况，选择平方和最大的一个

代码
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int maxn = 30;
int A[maxn];
int n, k, x, max_sqr; // 从A中n数中选k个数，使其和为x
vector<int> ans, temp;

void DFS(int index, int nowK, int sum, int sqr)
{
	if(nowK==k && sum==x)
	{
		if(sqr > max_sqr)
		{
			max_sqr = sqr;
			ans = temp; // 更新最优方案 
		}
		return ;
	}
	if(index>=n || sum>x || nowK>k)
	{
		return ;
	}
	//选index号
	temp.push_back(A[index]); 
	DFS(index+1, nowK+1, sum+A[index], sqr+A[index]*A[index]); // 不放回的选取 
	// DFS(index, nowK+1, sum+A[index], sqr+A[index]*A[index]); // 有放回的选取 
	temp.pop_back();
	
	// 不选index号
	DFS(index+1, nowK, sum, sqr);	
}

int main()
{
	freopen("input.txt", "r", stdin);
	scanf("%d %d %d", &n, &k, &x); 
	for(int i=0; i<n; i++)
	{
		scanf("%d", &A[i]);
	}
	DFS(0, 0, 0, 0);
	for(int i=0; i<ans.size(); i++)
	{
		printf("%d ", ans[i]);
	}
	
	fclose(stdin);
	return 0;
}
孱弱Lynch
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
专题训练——搜索专题
mengxianQAQ的博客
05-07 170
传送门 这套题我用的memset比较多，是因为这套题的数据量都比较小，想着省事 ，在实际做题中，如果时间限制短，或者多样例时，强烈不建议用memset，memset时间消耗太大。 A、Red and Black 题解：搜索模板题，dfs和bfs都可以，直接爆搜，能搜到 ’ . ’ 答案就加一 代码： #include<bits/stdc++.h> using namespace std; int ans=0; int dx[4]={0,0,1,-1}; int dy[4]={1,-1,0,
搜索专题
zxwsbg的博客
08-03 244
以DFS和BFS为主的复习。 DFS 题目1链接：http://hihocoder.com/problemset/problem/1310?sid=1348820 题意：和蓝桥杯省赛那题有点像。岛屿问题。题目求的是有多少个岛屿，多少个面积不同的岛屿，多少个形状不同的岛屿。 注意：这里形状相同指的是一个岛屿可以由另一个平移得到（不能旋转） 题解：         求有多少不同岛屿=...
简单搜索专题
weixin_58424264的博客
01-14 277
POJ2251-Dungeon Master POJ3278-Catch That Cow POJ3279-Fliptile POJ3126-Prime Path POJ3087-Shuffle'm Up POJ3414-Pots UVA11624-Fire! 马走日 POJ4124-海贼王之伟大航路 迷宫问题 鸣人和佐助 ACwing1113-红与黑 POJ1321-棋盘问题 POJ4116-拯救行动 百练4130-Saving Tang Monk...
搜索专题 A
jinghui_7的博客
05-30 272
1 简单描述 用中继器接收信号，相邻的中继器不互相干扰。如果相邻的中继器使用不同的频道，那么就不会相互干扰。使用的中继频道数尽量减少。 2 思路 #include #include #include #include #include #include #include #include #include #include using namespa
网站营销推广专题.ppt
11-12
3. **人员配置**：指派专门的团队或人员负责持续的推广工作，保持营销活动的连贯性。 4. **合作与协助**：与专业机构如中搜合作，获取营销推广方面的专业支持。 在开始推广前，要做好充分的准备： 1. **系统分析*...
计算机培训专题计划.doc
12-06
同时，教师将学习如何接入互联网，使用浏览器浏览网页，保存和下载资料，以及利用搜索引擎获取信息。 培训还特别强调了文字录入技巧，要求教师能在限定时间内熟练输入英文字符、汉字和特殊符号，并掌握至少一种汉字...
学习活动专题网站 v9.1
10-04
6. **文件"zt_v9.1"**：此文件可能是系统的核心组件或安装包，"zt"可能代表“专题”或“站点”的拼音缩写，".v9.1" 表示这是系统的第9个版本的第1次更新，说明软件经历了持续改进和升级。 综合上述信息，"学习活动...
绿色活动专题网页模板
01-22
【绿色活动专题网页模板】是一种专门用于创建与环保、生态或者可持续发展相关的活动宣传网页的设计方案。这种模板通常包含了一系列预设的布局、颜色搭配、图像元素和文字样式，旨在帮助设计者快速构建一个视觉上吸引...
网站招商专题计划书.doc
最新发布
12-18
通过定期更新网站内容，保持与用户的互动，可以持续吸引新用户并巩固现有合作关系。 【网上销售平台招商商业策划书】 网上销售平台的招商商业策划书强调了企业合作的优势互补和互惠互利原则。以e国电子商务企业为...
搜索专题（一）
chenkainan1023的博客
02-06 778
  搜索的种类： 搜索用很多实用和高效的算法。 举个栗子：广度优先搜索（bfs），深度优先搜索（dfs），枚举大法，蒙特卡洛树等等——详见百度百科《搜索算法》。   常用搜索简介: 广度优先搜索： 广度优先搜索，又称宽度优先搜索，简称广搜或宽搜。从当前位置开始进行四面八方搜索。 深度优先搜索： 深度优先搜索，简称深搜。与广度优先搜索相反，从当前位置一直向前搜索，知道不能搜索再改变...
搜索专题总结
Rayment的博客
08-22 496
搜索专题总结
图的遍历之 深度优先搜索和广度优先搜索
xiedeacc的专栏
06-01 2900
出自：http://www.cnblogs.com/skywang12345/p/3711483.html 图的遍历之 深度优先搜索和广度优先搜索 本章会先对图的深度优先搜索和广度优先搜索进行介绍，然后再给出C/C++/Java的实现。 目录  1. 深度优先搜索的图文介绍  1.1 深度优先搜索介绍  1.2 深度优先搜索图解  2. 广度优先搜索的图文介绍 
POJ搜索专题（转转）
Paradiser
07-24 1707
1010 stamps 1011 sticks Accepted 2006-08-03 04:09 1020 Anniversary Cake 1022 Packing Unit 4D Cubes 1024 Tester Program 1054 The Troublesome Frog 1062 昂贵的聘礼暂告一段落，先把DP题做一下，因为两者有很多交叉的地方，有很多题DP和搜索都可
搜索专题 Q
jinghui_7的博客
05-15 207
1、简单描述 素数环，第一个位置为1，前后两个数相加和为素数。 2、思路 #include #include #include using namespace std; int n,a[21]; bool vis[21]={0}; int prime[12]={2,3,5,7,11,13,17,19,23,29,31,37};//1~20任意两个数相加和为素数的所有素数和 bool is
Top-k Query Processing on Encrypted Databases with Strong Security Guarantees
qq_28334237的博客
10-09 821
摘要 外包云数据库中的隐私问题最近变得越来越重要，并且已经提出了许多关于加密数据的高效且可扩展的查询处理方法。 但是，如何安全地处理云中加密数据库的top-k排名查询的工作非常有限。 在本文中，我们专注于这个问题：对外包数据库的top-k查询进行安全和高效的处理。 特别是，我们提出了第一个有效且可证明的安全top-k查询处理结构，它实现了自适应CQA安全性。 我们开发了一个名为EHL的加密数据结...
精确Top-K检索及其加速方法探讨
iTer的专栏
10-14 3085
前言 目标：从文档集的所有文档中找出K个离查询最近的文档 （一般）步骤：对每个文档评分（余弦相似度），按照评分高低排序，选出前K个文档 但是对于搜索引擎来说，文档集很大，所以计算量会很大，效率就很低 如何加速： 思路一：加速每个余弦相似度的计算 思路二：不对所有的文档的评分结果排序而直接选出Top-K 思路三：能否不需要计算所有N篇文档的得分 加速余弦计算
"互联网二手市场项目商业计划书 - 市场分析与商业专题综合计划
1. 便捷的用户体验：通过简化交易流程、提供一键上架和搜索、智能价格评估等功能，为用户提供便捷的二手交易体验。 2. 多样化的商品种类：除了常见的手机、电脑等商品，我们还将推出更多的商品种类，如家居用品、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值