java电梯算法

㈠ 怎么用java实现apriori算法

作者：何史提
链接：https://www.hu.com/question/22590018/answer/26646688
来源：知乎
着作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Apriori算法的理念其实很简单，可是实现起上来却复杂无比，因为当中无可避免用Set和Hash Table等高阶的数据结构，而且有很多loop用以读取数据。
我不建议用Java，应改用Python或Scala一类的语言。如果用Python，代码大概50行左右，但可以想象用Java便看起来复杂得多。看如下：

from operator import and_
from itertools import combinations

class AprioriAssociationRule:
def __init__(self, inputfile):
self.transactions = []
self.itemSet = set([])
inf = open(inputfile, 'rb')
for line in inf.readlines():
elements = set(filter(lambda entry: len(entry)>0, line.strip().split(',')))
if len(elements)>0:
self.transactions.append(elements)
for element in elements:
self.itemSet.add(element)
inf.close()
self.toRetItems = {}
self.associationRules = []

def getSupport(self, itemcomb):
if type(itemcomb) != frozenset:
itemcomb = frozenset([itemcomb])
within_transaction = lambda transaction: rece(and_, [(item in transaction) for item in itemcomb])
count = len(filter(within_transaction, self.transactions))
return float(count)/float(len(self.transactions))

def runApriori(self, minSupport=0.15, minConfidence=0.6):
itemCombSupports = filter(lambda freqpair: freqpair[1]>=minSupport,
map(lambda item: (frozenset([item]), self.getSupport(item)), self.itemSet))
currentLset = set(map(lambda freqpair: freqpair[0], itemCombSupports))
k = 2
while len(currentLset)>0:
currentCset = set([i.union(j) for i in currentLset for j in currentLset if len(i.union(j))==k])
currentItemCombSupports = filter(lambda freqpair: freqpair[1]>=minSupport,
map(lambda item: (item, self.getSupport(item)), currentCset))
currentLset = set(map(lambda freqpair: freqpair[0], currentItemCombSupports))
itemCombSupports.extend(currentItemCombSupports)
k += 1
for key, supportVal in itemCombSupports:
self.toRetItems[key] = supportVal
self.calculateAssociationRules(minConfidence=minConfidence)

def calculateAssociationRules(self, minConfidence=0.6):
for key in self.toRetItems:
subsets = [frozenset(item) for k in range(1, len(key)) for item in combinations(key, k)]
for subset in subsets:
confidence = self.toRetItems[key] / self.toRetItems[subset]
if confidence > minConfidence:
self.associationRules.append([subset, key-subset, confidence])

㈡ 算法设计 爬楼梯类型,共n阶楼梯,一次最多爬m阶，用JAVA或者C或者C++

循环，，，，，好多循环，，，，哇，，，，实现了
#include<string.h>
#include<iostream>
#include<stack>
using namespace std;

int main()
{
int n = 0, m = 0, sum = 0, cnt = 0;

cout << "输入阶梯数：" << endl;
cin >> n;
cout << "输入最多爬的阶梯数：" << endl;
cin >> m;

if (n <= 0)
{
cout << "就一种，上去了!" << endl;
}
if (m <= 0)
{
cout << "你想上是不可能的！" << endl;
}
int i;
stack<int> sk;

do
{

if (sum <= n)
{
++cnt;

while (sum <= n)
{
sk.push(1);
++sum;
}
}

if (!sk.empty())
{
sum -= sk.top();
sk.pop();
}
else
{
cout << cnt << endl;
return 0;
}
HHH:
if (!sk.empty())
{
i = sk.top();
}
else
{
cout << cnt << endl;
return 0;
}

if (i < m)
{
++i;
}
else
{
if (!sk.empty())
{
sum -= sk.top();
sk.pop();
goto HHH;
}
else
{
cout << cnt << endl;
return 0;
}

}
if (!sk.empty())
{
sum -= sk.top();
sk.pop();
}
else
{
cout << cnt << endl;

return 0;
}
sk.push(i);
sum += i;

} while (1);

return 0;
}

㈢ 用Java编写程序，设计一个模拟电梯运行的类

最佳答案代码如下：

public class ElevatorModel implenent ElevatorModelListener{
ElevatorShaft elevatorShaft;//电梯车箱
Floor firstFloor;
Floor secondFloor;

public void addPerson(Person person);
//实现ElevatorModelListener接口的所有方法

}

public abstract class Location{
String locationName;//可能占据的三个位置firstFloor; secondFloor;elevator中的其中一个位置。

public Button getButton();
public Door getDoor();
}

public class Floor extends Location{
public Floor(String firstFloor,String secondFloor);

public Button getButton();//具体实现
public Door getDoor();//具体实现
public ElevatorShaft getElevatorShaft();
}

public class Door implenent ElevatorMoveListener{
boolean open;//门是开的关的
public void openDoor();//开门
public viod clossDoor();//关门
}

public class Button implenent ElevatorMoveListener{
boolean pressed;
public void pressButton();//按下按钮
public void resetButton();//释放按钮
public void elevatorArrived();//电梯到来
}

public class ElevatorShaft{//电梯乘箱
Elevator elevator;//电梯
Button firstFloorButton,secondFloorButton;//出发层的按钮和到达层的按钮 Door firstFloorDoor,secondFloorDoor;//出发的门和到达的门
Light firstFloorLight,secondFloorLight;//灯

//监听器
DoorListener doorListener;
ButtonListener buttonListener;
LightListener ligthListener;
BellListener bellListener;
ElevatorMoveListener elevatorMoveListener;
Set set;
}

public class Light implenent ElevatorMoveListener{
boolean lightOn;//代表灯的状态，亮或灭
public void turnOnLight();
public void turnOffLight();

public void elevatorDeparted();//具体实现
public void elevatorArrived();//具体实现
}

public class Bell implenent ElevatorMoveListener{
public void ringBell();
public void elevatorDeparted();//具体实现
public void elevatorArrived();//具体实现
}

public class Elevator extends Location implenets
ButtonListener,DoorListener,BellListener,Runable
{//电梯乘箱
boolean moving;
boolean summoned;//描述Elevator是在移动还是已经补召唤
Floor currentFloor;//当前正在提供服务的Floor
Floor destinationFloor ; //代表将要到达的Floor
Button elevatorButton;
Door elevatorDoor;
Bell bell;

public void run();// 实现
public void requestElevator();//请求Elevator并产生排队请求。 }

public class Person extends Thread{
Location类对象（或是位于Floor上，或是出处在Elevator中）; int ID;
boolean moving;

public void run();//具体实现
public void enterAndRideElevator();
}

㈣ 电梯的工作程序代码用JAVA语言可以吗可以的话速求！

java 肯定可以，首先要解决虚拟机，就是电梯程序当中要有虚拟机运行，然后在虚拟机的基础上编写java程序去执行。

但是一般直接和硬件交互 一般用PLC

㈤ java用递归算法编写求1~n的累加和

importjava.util.Scanner;
publicclassZhi2{
publicstaticvoidmain(String[]args){
intnumber=1;
intsum=0;
intn;
Scannerscanner=newScanner(System.in);
n=scanner.nextInt();
for(;number<=n;number++){
sum+=number;
}
System.out.println(+sum);
}
}

㈥ java模拟实现两部电梯同时工作的高效算法

1. 各电梯控制：
a. 实现一个方法，返回本电梯到请求楼层上、下的时间（或者简单点的，层数）；
b. 任务接受：接受用户楼层上、下请求任务

2. 主控部分：
a. 当用户按下上、下请求时，通过调用两个电梯的上面所说的服务，进行比较决断最优时间电梯；
b. 给最最优电梯发送任务；
3. 主控与各电梯控制之间的通讯可以通过多种方式实现；

㈦ java中递归算法是什么怎么算的

一、递归算法基本思路：

Java递归算法是基于Java语言实现的递归算法。递归算法是一种直接或者间接调用自身函数或者方法的算法。递归算法实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法表示问题的解。递归往往能给我们带来非常简洁非常直观的代码形式，从而使我们的编码大大简化，然而递归的思维确实跟我们的常规思维相逆的，通常都是从上而下的思维问题，而递归趋势从下往上的进行思维。

二、递归算法解决问题的特点：

【1】递归就是方法里调用自身。

【2】在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

【3】递归算法代码显得很简洁，但递归算法解题的运行效率较低。所以不提倡用递归设计程序。

【4】在递归调用的过程中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等，所以一般不提倡用递归算法设计程序。

【5】在做递归算法的时候，一定把握出口，也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。其实这个出口就是一个条件，当满足了这个条件的时候我们就不再递归了。

三、代码示例：

publicclassFactorial{

//thisisarecursivefunction

intfact(intn){

if(n==1)return1;

returnfact(n-1)*n;

}}

publicclassTestFactorial{publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

Factorialfactorial=newFactorial();

System.out.println("factorial(5)="+factorial.fact(5));

}
}

代码执行流程图如下：

此程序中n=5就是程序的出口。