protected override void VisitNode(BFSQueue queue, BFSNode node, int sourceUser, int neighbourhoodDistance)
{
Dictionary <int, float> indexes = new Dictionary <int, float>();
foreach (int user in this.originalTrustMatrix[node.value])
{
if (!this.estimatedTrustMatrix[sourceUser].Contains(user))
{
indexes[user] = ResourceAllocationIndex(sourceUser, user);
}
}
List <KeyValuePair <int, float> > indexesList = indexes.ToList();
if (topN.HasValue)
{
indexesList.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
if (topN < indexesList.Count)
{
indexesList.RemoveRange(0, indexesList.Count - topN.Value);
}
}
int distance = node.distance + 1;
foreach (KeyValuePair <int, float> pair in indexesList)
{
int user = pair.Key;
estimatedTrustMatrix[sourceUser, user] = BasicTrustMetric(neighbourhoodDistance, distance);
queue.Enqueue(new BFSNode(pair.Key, distance));
}
}
public static Matrix <float> BuildRABasedTrust(Matrix <float> trustMatrix, int neighbourhoodDistance)
{
Matrix <float> estimatedTrustMatrix = trustMatrix.Clone();
Matrix <float> raMatrix = new Matrix <float>();
foreach (int sourceUser in trustMatrix.Rows)
{
BFSQueue queue = new BFSQueue(neighbourhoodDistance);
foreach (int trustedUser in trustMatrix[sourceUser])
{
queue.Enqueue(new BFSNode(trustedUser, 1));
}
while (queue.Count() > 0)
{
BFSNode node = queue.Deque();
int user = node.value;
int distance = node.distance;
if (distance == neighbourhoodDistance)
{
break;
}
if (trustMatrix.HasRow(user))
{
Dictionary <int, float> RAIndexes = new Dictionary <int, float>();
foreach (int trustedUser in trustMatrix[user])
{
if (!trustMatrix[sourceUser].Contains(trustedUser))
{
if (!(raMatrix.HasRow(sourceUser) && raMatrix[sourceUser].Contains(trustedUser)))
{
raMatrix[sourceUser, trustedUser] = ResourceAllocationIndex(trustMatrix, sourceUser, trustedUser);
}
RAIndexes[trustedUser] = raMatrix[sourceUser, trustedUser];
}
}
List <KeyValuePair <int, float> > RAList = RAIndexes.ToList();
RAList.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
for (int i = 0; i < 15 && i < RAList.Count; i++)
{
queue.Enqueue(new BFSNode(RAList[i].Key, distance + 1));
estimatedTrustMatrix[sourceUser, RAList[i].Key] = BasicTrustMetric(neighbourhoodDistance, distance + 1);
}
}
}
}
return(estimatedTrustMatrix);
}
public static Matrix <float> BuildCommonNeighboursBasedTrust(Matrix <float> trustMatrix, int neighbourhoodDistance)
{
Matrix <float> estimatedTrustMatrix = trustMatrix.Clone();
Matrix <float> cnMatrix = new Matrix <float>();
foreach (int sourceUser in trustMatrix.Rows)
{
BFSQueue queue = new BFSQueue(neighbourhoodDistance);
foreach (int trustedUser in trustMatrix[sourceUser])
{
queue.Enqueue(new BFSNode(trustedUser, 1));
}
while (queue.Count() != 0)
{
BFSNode node = queue.Deque();
int user = node.value;
int distance = node.distance;
if (distance == neighbourhoodDistance)
{
break;
}
if (trustMatrix.HasRow(user))
{
Dictionary <int, float> commonNeighbours = new Dictionary <int, float>();
foreach (int trustedUser in trustMatrix[user])
{
if (!trustMatrix[sourceUser].Contains(trustedUser))
{
if (!(cnMatrix.HasRow(sourceUser) && cnMatrix[sourceUser].Contains(trustedUser)))
{
cnMatrix[sourceUser, trustedUser] = CommonNeighbours(trustMatrix, sourceUser, trustedUser);
}
commonNeighbours[trustedUser] = cnMatrix[sourceUser, trustedUser];
}
}
List <KeyValuePair <int, float> > CNList = commonNeighbours.ToList();
CNList.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
for (int i = 0; i < 15 && i < CNList.Count; i++)
{
queue.Enqueue(new BFSNode(CNList[i].Key, distance + 1));
estimatedTrustMatrix[sourceUser, CNList[i].Key] = BasicTrustMetric(neighbourhoodDistance, distance + 1);
}
}
}
}
return(estimatedTrustMatrix);
}
protected override void VisitNode(BFSQueue queue, BFSNode node, int sourceUser, int neighbourhoodDistance)
{
foreach (int user in this.originalTrustMatrix[node.value])
{
if (!this.estimatedTrustMatrix[sourceUser].Contains(user))
{
int distance = node.distance + 1;
this.estimatedTrustMatrix[sourceUser, user] = BasicTrustMetric(neighbourhoodDistance, distance);
queue.Enqueue(new BFSNode(user, distance));
}
}
}
public static Matrix <float> BuildJaccardIndexTrustMatrix2(Matrix <float> trustMatrix, int neighbourhoodDistance)
{
Matrix <float> estimatedTrustMatrix = trustMatrix.Clone();
Matrix <float> jaccardMatrix = new Matrix <float>();
foreach (int sourceUser in trustMatrix.Rows)
{
BFSQueue queue = new BFSQueue(neighbourhoodDistance);
foreach (int trustedUser in trustMatrix[sourceUser])
{
queue.Enqueue(new BFSNode(trustedUser, 1));
}
while (queue.Count() != 0)
{
BFSNode node = queue.Deque();
int user = node.value;
int distance = node.distance;
if (distance == neighbourhoodDistance)
{
break;
}
if (trustMatrix.HasRow(user))
{
foreach (int trustedUser in trustMatrix[user])
{
if (!(jaccardMatrix.HasRow(sourceUser) && jaccardMatrix[sourceUser].Contains(trustedUser)))
{
jaccardMatrix[sourceUser, trustedUser] = jaccardMatrix[trustedUser, sourceUser] = JaccardIndex(trustMatrix, sourceUser, trustedUser);
}
float jaccardIndex = jaccardMatrix[sourceUser, trustedUser];
if (jaccardIndex > _Threshold)
{
estimatedTrustMatrix[sourceUser, trustedUser] = BasicTrustMetric(neighbourhoodDistance, distance + 1);
queue.Enqueue(new BFSNode(trustedUser, distance + 1));
}
}
}
}
}
return(estimatedTrustMatrix);
}
/// <summary>BFS Puzzle</summary>
public void BFS_Search()
{
ThreadPool.QueueUserWorkItem(o => /// https://dotblogs.com.tw/yc421206/2011/10/10/40840
{
AnswerFound = false;
///清資料
DateTime StartTime = DateTime.Now;
BFSQueue.Clear();
TimeCost = 0;
Parent.Clear();
///初始化
BFSQueue.Enqueue(InitValue);
Parent.Add(InitValue, InitValue);
Degree = -1;
CurrentDegree = 0;
int count = 0;
while (!AnswerFound && BFSQueue.Count > 0)
{
ulong bfsTop = BFSQueue.Dequeue();
CurrentDegree = Cost(bfsTop, out _);
if (bfsTop == TargetValue)
{
AnswerFound = true;
BFSQueue.Clear();
break;
}
foreach (ulong next in NextPossibleState(bfsTop))
{
if (!Parent.Contains(next))
{
BFSQueue.Enqueue(next);
Parent.Add(next, bfsTop);
}
}
count++;
TimeCost = (DateTime.Now - StartTime).TotalMilliseconds;
}
DateTime FinishTime = DateTime.Now;
TimeCost = (FinishTime - StartTime).TotalMilliseconds;
Degree = Cost(TargetValue, out Route); // 計算最終狀態到初始狀態花的cost
});
}
public static Matrix <float> BuildSaltonIndexTrustMatrix2(Matrix <float> trustMatrix, int neighbourhoodDistance)
{
Matrix <float> estimatedTrustMatrix = new Matrix <float>();
Matrix <float> saltonMatrix = new Matrix <float>();
foreach (int sourceUser in trustMatrix.Rows)
{
BFSQueue queue = new BFSQueue(neighbourhoodDistance);
estimatedTrustMatrix.AddRow(sourceUser);
foreach (int trustedUser in trustMatrix[sourceUser])
{
queue.Enqueue(new BFSNode(trustedUser, 1));
}
while (queue.Count() != 0)
{
BFSNode node = queue.Deque();
int user = node.value;
int distance = node.distance;
if (!estimatedTrustMatrix[sourceUser].Contains(user))
{
saltonMatrix[sourceUser, user] = saltonMatrix[user, sourceUser] = SaltonIndex(trustMatrix, sourceUser, user);
if (saltonMatrix[sourceUser, user] > _Threshold)
{
estimatedTrustMatrix[sourceUser, user] = BasicTrustMetric(neighbourhoodDistance, distance);
if (trustMatrix.Rows.Contains(user))
{
foreach (int trustedUser in trustMatrix[user])
{
queue.Enqueue(new BFSNode(trustedUser, distance + 1));
}
}
}
}
}
}
return(estimatedTrustMatrix);
}
protected override void VisitNode(BFSQueue queue, BFSNode node, int sourceUser, int neighbourhoodDistance)
{
Dictionary <int, float> commonNeighbours = new Dictionary <int, float>();
foreach (int user in this.originalTrustMatrix[node.value])
{
if (!this.estimatedTrustMatrix[sourceUser].Contains(user))
{
commonNeighbours[user] = CN(sourceUser, user);
}
}
List <KeyValuePair <int, float> > cnList = commonNeighbours.ToList();
if (topN.HasValue)
{
cnList.Sort((pair1, pair2) => pair1.Value.CompareTo(pair2.Value));
if (topN < commonNeighbours.Count)
{
cnList.RemoveRange(topN.Value, commonNeighbours.Count - topN.Value);
}
}
}
public virtual Matrix <float> BuildMatrix(int neighbourhoodDistance)
{
foreach (int sourceUser in this.originalTrustMatrix.Rows)
{
BFSQueue queue = new BFSQueue(neighbourhoodDistance);
foreach (int trustedUser in this.originalTrustMatrix[sourceUser])
{
queue.Enqueue(new BFSNode(trustedUser, 1));
}
while (queue.Count() != 0)
{
BFSNode node = queue.Deque();
if (this.originalTrustMatrix.HasRow(node.value))
{
VisitNode(queue, node, sourceUser, neighbourhoodDistance);
}
}
}
return(this.estimatedTrustMatrix);
}
protected abstract void VisitNode(BFSQueue queue, BFSNode node, int sourceUser, int neighbourhoodDistance);
