dlx算法

❶ 将N个数分成M组,使每组的和尽量相近，有木有研究这个的算法啊

先求总和和平均数，然后排序，按平均数为总和尽量配对

❷ 数独新手疑问：所有数独题是不是完全靠推理可以完成

不一定

因为数独题出来时，出题人也不一定能保证解是唯一，我就做过好多次，可以多选的，那时候就推理不出来了。有时候在二选一时，只能先选一个试试，记下这个点，最后如果解不开了，再回到这个点重新选另一个数开始.下面就是我做过了，可以多选的一个例子：一般出现一个可以多选的，就会同时出现四个（是指不带斜线的，只有横竖和九宫）

❸ DLX算法的时间复杂度是多少简单分析一下。

每当调用这个函数时会产生2个递归分支，所以时间复杂度是O(2^n)。
n==1时，调用1次rec(1)，
n==2时，调用1次rec(2)，2次rec(1)，
n==3时，调用1次rec(3)，2次rec(2)，4次rec(1)，
以此类推，总的调用次数为2^0+2^1+2^2++2^(n-1)=2^n-1，
因为函数内不存在循环，T(n)=(2^n-1)*1=2^n-1，
存在正的常数c,n0使得对于任意n>=n0时有T(n)<=c*2^n，
所以这个时间复杂度是O(2^n)。

❹ 离散对数的离散对数概述

是在整数中，一种基于同余运算和原根的一种对数运算：当模m有原根时，设L为模m的一个原根，则当?x≡L^k(mod m)时： IndLx≡?k (mod Φ(m))，此处的IndLx为 x以整数L为底，模Φ(m)时的离散对数值。
或者简单描述离散对数问题为：给定一个质数p，和有限域Zp上的一个本原元a，对Zp上整数b，寻找唯一的整数c，使得a^c≡b(mod p)。一般的，如果仔细选择p，则认为该问题是难解的，且目前还没有找到计算离散对数问题的多项式时间算法。为了抵抗已知的攻击，p至少应该是150位的十进制整数，且p-1至少有一个大的素数因子。
性质 离散对数和一般的对数有着相类似的性质：

❺ dlx是什么格式

DLX是一种多元未饱和型指令集结构。称之为多元未饱和型结构，是因为它不仅体现了当今多种机器（AMD29K、DEC station 3100、HP850、IBM 801、Intel i860、MIPS M/120A、MIPS M/1000、Motorola 88k、RISC I、SGI4D/60、SPARC station 1、Sun 4/110、Sun 4/260等）指令集结构的共同特点，而且它还将会体现未来一些机器的指令集结构的特点。这些机器的指令集结构设计思想都和DLX指令集结构的设计思想十分相似，它们都强调：具有一个简单的Load/Store指令集；注重指令流水效率；简化指令的译码；高效支持编译器。 在计算机科学中，DLX是Dancing Links的缩写，该算法由Donald Knuth提出，有效地利用与Algorithm X。

❻ 生成随机数独矩阵的算法的算法是

可以采用dlx加上随机和成初始数独，同学我觉得你的分太少了，能加点吗
我在写程序马上写好给你

#include "stdlib.h"
#include "time.h"
#include<stdio.h>
#include<string.h>
const int MAX=10;
const int MAXM=81*4;
const int MAXN=81*9;
int CS=1;
char s[MAX*MAX];
int table[MAX*MAX][MAX][MAX];
struct
{
int l,r,u,d,sum,x,y;
}node[MAX*MAX*MAX*MAX*MAX];

inline void move(int c)
{
int i,j;
node[node[c].l].r=node[c].r;
node[node[c].r].l=node[c].l;
for(i=node[c].d;i!=c;i=node[i].d)
{
for(j=node[i].r;j!=i;j=node[j].r)
{
node[node[j].y].sum--;
node[node[j].u].d=node[j].d;
node[node[j].d].u=node[j].u;
}
}
}//move

inline void sume(int c)
{
int i,j;
for(i=node[c].u;i!=c;i=node[i].u)
{
for(j=node[i].l;j!=i;j=node[j].l)
{
node[node[j].y].sum++;
node[node[j].u].d=j;
node[node[j].d].u=j;
}
}
node[node[c].l].r=c;
node[node[c].r].l=c;
}//sume

bool DFS(int deep)
{
int i,col,min=MAXN*MAXM,x,y,j;
if(node[0].r==0)
{
return 1;
}
for(i=node[0].r;i;i=node[i].r)
{
if(node[i].sum<min)
{
col=i;
min=node[i].sum;
}
}
if(min==0) return 0;
move(col);
for(i=node[col].d;i!=col;i=node[i].d)
{
for(j=node[i].r;j!=i;j=node[j].r)
move(node[j].y);
if(DFS(deep+1))
{
y=node[i].x%9;
if(y==0)
y=9;
x=(node[i].x-y)/9+1;
s[x-1]=y+'0';
return 1;
}
for(j=node[i].l;j!=i;j=node[j].l)
sume(node[j].y);
}
sume(col);
return 0;
}//DFS

void del()
{
int i,k,x;
for(i=0;s[i];i++)
{
if(s[i]=='.')
continue;
for(k=0;k<4;k++)
{
x=table[i+1][s[i]-'0'][k];
node[node[x].l].r=node[x].r;
node[node[x].r].l=node[x].l;
}
}
}

void make_link()
{
int i,k,fir,x,d;
int len=MAXM;
for(i=0;s[i];i++)
{
if(s[i]!='.')
continue;
for(d=1;d<MAX;d++)
{
for(k=0;k<4;k++)
{
x=table[i+1][d][k];
if(node[node[x].r].l!=x)
break;
}

if(k<4)
continue;
fir=-1;
for(k=0;k<4;k++)
{
x=table[i+1][d][k];
if(node[node[x].l].r!=x)
continue;
len++;
if(fir==-1)
fir=len;

node[x].sum++;
node[node[x].u].d=len;
node[len].d=x;
node[len].u=node[x].u;
node[x].u=len;
node[len].x=i*9+d;
node[len].y=x;
node[len].l=len-1;
node[len].r=len+1;
}
if(fir!=-1)
{
node[fir].l=len;
node[len].r=fir;
}
}
}
}//make_link

int fun(int i,int d,int j)
{
int x,y;
if(j==0)
return (i-1)/9*9+d;
else if(j==1)
return (i-1)%9*9+d+81;
else if(j==2)
{
x=(i-1)/9+1;
y=(i-1)%9+1;
x=(x-1)/3+1;
y=(y-1)/3+1;
return ((x-1)*3+y-1)*9+d+81*2;
}
else
return i+81*3;
}//fun
void make_table()
{
int i,j,d;
for(i=1;i<=81;i++)
for(d=1;d<MAX;d++)
for(j=0;j<4;j++)
table[i][d][j]=fun(i,d,j);
}//make_table

void init()
{
int i;
for(i=1;i<=MAXM;i++)
{
node[i].l=i-1;
node[i].r=i+1;
node[i].sum=0;
node[i].y=i;
node[i].x=0;
node[i].u=node[i].d=i;
}
node[0].r=1;
node[0].l=MAXM;
node[MAXM].r=0;
}//init
int solve(char s[])
{

init();
del();
make_link();
DFS(0);
printf("case#%d:\n",CS++);
puts(s);
return 0;
}
bool used[10]={false};

void gen(int deep)
{
int i;
if(deep==9)
{
solve(s);
return;
}
if(CS>10000)return;
for(i=1;i<10;i++)
{
if(used[i])continue;
used[i]=true;
s[deep]=i+'0';
gen(deep+1);
if(CS>10000)return;
used[i]=false;
}

}
int main()
{
make_table();
int i;
for(i=0;i<MAX*MAX;i++)
{
s[i]='.';
}
s[81]=0;
freopen("a.txt","w",stdout);
gen(0);
return 0;
}

❼ 请问ACM的正确入门方式是什么

一般的入门顺序：0. C语言的基本语法(或者直接开C++也行，当一个java选手可能会更受欢迎，并且以后工作好找，但是难度有点大)，【参考书籍：刘汝佳的《算法竞赛入门经典》，C++入门可以考虑《c++ primer plus》，java选手可以考虑《think in java》or中文版《java编程思想》，请远离谭浩强...】可以选择切一些特别水的题巩固以及适应一下ACM中常见的输入输出格式...例如杭电着名的100题 Problem Set。 一些进阶的算法以及复杂一些的数据结构（树状数组 线段树 平衡树 后缀数组 二分图匹配 网络流 费用流 割点 桥 强联通 双联通 最近公共祖先 四大DP(数位dp 区间dp 状压dp 概率dp) 博弈论SG函数 ）更高深的技巧，更复杂的数据结构（树链剖分，动态树，可持久化线段树，DLX，后缀自动机，回文树，斜率优化/单调队列优化/四边形优化DP，插头dp，莫比乌斯反演......）这部分最能体现人与人的差异了...智商碾压一般就在这部分。而要想拿到金牌，一般来说这些知识都要尽可能掌握。也许你会觉得性价比很低，学这么多东西，才"有可能”拿到牌子，但是收获的不一定是物质的牌子，还有学习过程的苦辣酸甜的经历（例如各种WA TLE RE MLE 之后的一次AC），还有和基友一起并肩作战切套题的同甘共苦，而且还锻炼了自己的学习能力（善用网络，谷歌，维基网络）。

❽ 汽车发动机开环和闭环的区别

开环控制和闭环控制的区别：

一、开环控制：控制器与被控对象间只有顺序作用而无反向联系且控制单方向进行。若组成系统的元件特性和参数值比较稳定，且外界干扰较小，开环控制能 够保持一定的精度。 缺点：精度通常较低、无自动纠偏能力。

二、闭环控制：闭环控制系统在输出端和输入端之间存在反馈回路，输出量对控制过程有直接影响。

开环控制系统是指汽车发动机只能根据预先设置的数据对喷油量进行控版制，而不能根据实际情况变化权进行油量控制的系统，一般有化油器车、不带三元净化器和养传感器的电喷汽油车及普通柴油车。闭环控制系统是指汽车发动机通过氧传感器能根据尾气排放中的氧含量数据对喷油量进行控制的系统，有目前市场上大多数销售的电喷汽油车和部分高档电喷柴油车。较直白的说一般带三元净化器和养传感器的电喷汽油车，都是闭环控制系统电喷车，反之却不一定。

由化油器到开环电喷控制系统至闭环控制系统的设计改进目的是节能与环保，带有三元净化器和养传感器的闭环控制系统电喷车才能达到国际环保验车标准。目前汽车制造商已停止了开环控制系统车辆的生产，北京、上海等许多城市也已不允许开环控制系统车辆上路，因其燃油的不完全燃烧会造成大气的污染。从生产成本而论，闭环控制系统车辆造价要比开环控制系统车辆高出5%以上。