Add penalty to previous path on point graph to prevent u-turns?

Hello, so I have a point graph set up in the above picture. I have each car choosing a random node on the point graph and following a path to it. Right now, the cars traveling on the road have a tendency to make u-turns to get to their next destination. For example, suppose the original path was from point A to point B. Once the car reaches point B, it then randomly chooses to travel to point C. Is there any way where I can force it to always take the yellow path instead of the purple path to prevent u-turns? I was thinking something along the lines of setting penalties for the previous path, but the penalties would have to only apply to a single agent as I don’t want the penalties to apply to the other cars on the road. Is there a feasible way to do this? I have included my pathfinding code below:

`using UnityEngine;
using System.Collections;
using System.Linq;
//Note this line, if it is left out, the script won’t know that the class ‘Path’ exists and it will throw compiler errors
//This line should always be present at the top of scripts which use %Pathfinding
using Pathfinding;

public class newPathfind : MonoBehaviour {
//The point to move to
private Vector3 targetPosition;
private bool pathComplete;
public bool ManualList = false;
public GameObject target1;
public GameObject target2;
public GameObject target3;
public GameObject target4;
public GameObject target5;
private GameObject[] Waypoints;
private GameObject[] oneway;
private GameObject[] twoway;
public static int randomPoint;
private Seeker seeker;
private CharacterController controller;
//The calculated path
public Path path;
//The AI’s speed per second
public float speed = 500;
//The max distance from the AI to a waypoint for it to continue to the next waypoint
public float nextWaypointDistance = 3;
//The waypoint we are currently moving towards
private int currentWaypoint = 0;

public void Start () {
	seeker = GetComponent<Seeker>();
	controller = GetComponent<CharacterController>();
	Vector3 randomLoc = Vector3.zero;
	if (ManualList) {
		Waypoints = new GameObject[5];
		Waypoints[0] = target1;
		Waypoints[1] = target2;
		Waypoints[2] = target3;
		Waypoints[3] = target4;
		Waypoints[4] = target5;
	} else {
		//Waypoints = GameObject.FindGameObjectsWithTag("network");
		twoway = GameObject.FindGameObjectsWithTag ("network");
		oneway = GameObject.FindGameObjectsWithTag ("oneway");
		Waypoints = oneway.Concat (twoway).ToArray ();
	}
	do {
		randomPoint = Random.Range (0, Waypoints.Length-1);
		randomLoc = Waypoints[randomPoint].transform.position;
		targetPosition = new Vector3 (randomLoc.x, gameObject.transform.position.y, randomLoc.z);
	} while ((Vector3.Distance(gameObject.transform.position, targetPosition) < 50f));
	//Start a new path to the targetPosition, return the result to the OnPathComplete function
	seeker.StartPath (transform.position,targetPosition, OnPathComplete);
}
public void OnPathComplete (Path p) {
	Debug.Log ("Yey, we got a path back. Did it have an error? "+p.error);
	if (!p.error) {
		path = p;
		//Reset the waypoint counter
		currentWaypoint = 0;
		pathComplete = true;
	}
}
public void FixedUpdate () {
	if (path == null) {
		return;
	}
	if (currentWaypoint >= path.vectorPath.Count && pathComplete == true) {
		Debug.Log ("End Of Path Reached");
		Start();
		pathComplete = false;
		return;
	}
	//Direction to the next waypoint
	Vector3 dir = Vector3.zero;
	if (currentWaypoint >= 0 && currentWaypoint < path.vectorPath.Count) {
		dir = (path.vectorPath [currentWaypoint] - transform.position).normalized;
	}
	if (dir != Vector3.zero) {
		transform.rotation = Quaternion.LookRotation (dir);
	}
	dir *= speed * Time.fixedDeltaTime;
	controller.SimpleMove (dir);
	//Check if we are close enough to the next waypoint
	//If we are, proceed to follow the next waypoint
	if (Vector3.Distance (transform.position,path.vectorPath[currentWaypoint]) < nextWaypointDistance) {
		currentWaypoint++;
		return;
	}
}
public void OnDisable () {
	seeker.pathCallback -= OnPathComplete;
} 

}
`

Ok, so I’m trying to set the penalty for the nodes right before the end of the path but I still can’t get it to not make necessary u-turns. Here’s what I have so far:

if (currentWaypoint >= 0 && currentWaypoint < path.vectorPath.Count) { if (Vector3.Distance (transform.position, path.vectorPath [currentWaypoint]) < nextWaypointDistance) { if(currentWaypoint == path.vectorPath.Count - 10){ Debug.Log ("Set penalty at " + currentWaypoint + "/" + path.vectorPath.Count); node = AstarPath.active.GetNearest(transform.position).node; bounds = new Bounds (new Vector3(node.position.x, node.position.y, node.position.z), new Vector3 (5.0f, 5.0f, 5.0f)); guo = new GraphUpdateObject(bounds); guo.addPenalty = 10000; guo.requiresFloodFill = false; guo.resetPenaltyOnPhysics = false; guo.updatePhysics = false; AstarPath.active.UpdateGraphs(guo); } currentWaypoint++; return; } }