package org.springblade.modules.words.internals;
|
|
import java.util.ArrayList;
|
import java.util.Hashtable;
|
import java.util.List;
|
import java.util.Map;
|
|
public class TrieNodeEx {
|
public Integer Char;
|
public boolean End;
|
public Integer Index;
|
public List<Integer> Results;
|
public Map<Integer, TrieNodeEx> m_values;
|
private Integer minflag = Integer.MAX_VALUE;
|
private Integer maxflag = 0;
|
public int Next;
|
|
public TrieNodeEx() {
|
m_values = new Hashtable<Integer, TrieNodeEx>();
|
Results = new ArrayList<Integer>();
|
}
|
|
public void Add(int c, TrieNodeEx node3) {
|
if (minflag > c) {
|
minflag = c;
|
}
|
if (maxflag < c) {
|
maxflag = c;
|
}
|
m_values.put(c, node3);
|
}
|
|
public void SetResults(Integer text) {
|
if (End == false) {
|
End = true;
|
}
|
if (Results.contains(text) == false) {
|
Results.add(text);
|
}
|
}
|
|
public boolean HasKey(Integer c) {
|
if (minflag <= c && maxflag >= c) {
|
return m_values.containsKey((int) c);
|
}
|
return false;
|
}
|
|
public void Rank(Integer oneStart, Integer start, boolean[] seats, boolean[] seats2, Integer[] has) {
|
if (maxflag == 0)
|
return;
|
if (minflag == maxflag) {
|
RankOne(oneStart, seats, has);
|
return;
|
}
|
List<Integer> keys = new ArrayList<Integer>();
|
m_values.forEach((k, v) -> {
|
keys.add((int) k);
|
});
|
|
Integer length = keys.size() - 1;
|
int[] moves = new int[keys.size() - 1];
|
for (int i = 1; i < keys.size(); i++) {
|
moves[i - 1] = maxflag - keys.get(i);
|
}
|
|
while (has[start] != null) {
|
start++;
|
}
|
Integer s = start < minflag ? minflag : start;
|
|
for (int i = s; i < s + (maxflag - minflag); i++) {
|
if (has[i] != null) {
|
for (int j = 0; j < length; j++) {
|
Integer p = i + moves[j];
|
if (seats2[p] == false) {
|
seats2[p] = true;
|
}
|
}
|
}
|
}
|
Integer max = 0;
|
for (int i = s + (maxflag - minflag); i < has.length; i++) {
|
if (has[i] == null) {
|
if (seats2[i]) {
|
continue;
|
}
|
Integer next = i - (Integer) maxflag;
|
if (seats[next])
|
continue;
|
SetSeats(next, seats, has);
|
max = i;
|
break;
|
} else {
|
for (int j = 0; j < length; j++) {
|
Integer p = i + moves[j];
|
if (seats2[p] == false) {
|
seats2[p] = true;
|
}
|
}
|
}
|
}
|
start += keys.size() / 2;
|
for (int p = start; p < max + maxflag - start + 1; p++) {
|
if (seats2[p] == true) {
|
seats2[p] = false;
|
}
|
}
|
}
|
|
private void RankOne(Integer start, boolean[] seats, Integer[] has) {
|
while (has[start] != null) {
|
start++;
|
}
|
Integer s = start < minflag ? minflag : start;
|
|
for (Integer i = s; i < has.length; i++) {
|
if (has[i] == null) {
|
Integer next = i - (Integer) minflag;
|
if (seats[next])
|
continue;
|
SetSeats(next, seats, has);
|
break;
|
}
|
}
|
start++;
|
}
|
|
|
private void SetSeats(Integer next, boolean[] seats, Integer[] has) {
|
Next = next;
|
seats[next] = true;
|
|
m_values.forEach((key, value) -> {
|
int position = next + key;
|
has[position] = value.Index;
|
});
|
}
|
|
}
|
